{"version":3,"file":"providers.cjs","names":["isNil","TreeNodeAccessor","LRUCache","getCfgRenderCtx","DataColumn","AccessorEntriesProvider","ResultPoolEntriesProvider"],"sources":["../../../src/columns/column_providers/providers.ts"],"sourcesContent":["import {\n  AccessorEntriesProvider,\n  ResultPoolEntriesProvider,\n  type PColumn,\n  type PObjectId,\n  type UpstreamBlockCtx,\n} from \"@milaboratories/pl-model-common\";\nimport { AccessorHandle, PColumnDataUniversal, TreeNodeAccessor } from \"../../render\";\nimport { DataColumn, DataColumnRecipe } from \"../data_column\";\nimport { getCfgRenderCtx } from \"../../internal\";\nimport { isNil } from \"es-toolkit\";\nimport { LRUCache } from \"lru-cache\";\n\n/**\n * Data source for sandbox column-list builders. Has nothing to say about\n * id-resolution — `ColumnRegistry` (in `@milaboratories/pl-model-common`)\n * consumes the separate `ColumnEntriesProvider` interface for that.\n *\n * Same name as the factory function below — they merge into one TS\n * declaration: `ColumnsProvider` is callable AND the interface type.\n */\nexport interface ColumnsProvider {\n  /** Returns all currently known PColumn columns as lazy views. */\n  getColumns(): DataColumnRecipe<PObjectId>[];\n  /** Whether the provider has finished enumerating all its columns. */\n  isFinal(): boolean;\n}\n\n/**\n * Unified memoised factory dispatching to the right provider flavour by the\n * source shape:\n * - `TreeNodeAccessor` → {@link AccessorColumnsProvider}\n *   (indexed by `root.handle`, walks the accessor tree once per root).\n * - `UpstreamBlockCtx<AccessorHandle>[]` (or omitted — pulled from the\n *   ambient ctx) → {@link ResultPoolColumnsProvider}\n *   (indexed by a content-hash of the block list).\n *\n * Both branches return cached instances within their LRU window, so repeated\n * calls with the same source skip re-walking / re-hashing.\n */\nexport function ColumnsProvider(\n  source?: TreeNodeAccessor | ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>,\n) {\n  if (isNil(source) || Array.isArray(source)) {\n    return ResultPoolColumnsProvider(source);\n  } else if (source instanceof TreeNodeAccessor) {\n    return AccessorColumnsProvider(source);\n  } else {\n    throw new Error(\"Unknown columns provider source\");\n  }\n}\n\n/**\n * Memoised constructor — same `root.handle` returns the same\n * {@link AccessorColumnsProviderImpl}, so `indexAccessorRoot` runs once per\n * accessor root (within the LRU window).\n */\nconst _accessorProviderCache = new LRUCache<AccessorHandle, AccessorColumnsProviderImpl>({\n  max: 64,\n});\nexport function AccessorColumnsProvider(root: TreeNodeAccessor): AccessorColumnsProvider {\n  let provider = _accessorProviderCache.get(root.handle);\n  if (provider === undefined) {\n    provider = new AccessorColumnsProviderImpl(root);\n    _accessorProviderCache.set(root.handle, provider);\n  }\n  return provider;\n}\n\n/**\n * Memoised constructor — same `rawPool` content returns the same\n * {@link ResultPoolColumnsProviderImpl}, so `indexPoolBlock` runs once per\n * pool snapshot (within the LRU window).\n */\nconst _resultPoolProviderCache = new LRUCache<string, ResultPoolColumnsProviderImpl>({ max: 4 });\nexport function ResultPoolColumnsProvider(\n  rawPool: ReadonlyArray<\n    UpstreamBlockCtx<AccessorHandle>\n  > = getCfgRenderCtx().getUpstreamBlockCtx(),\n): ResultPoolColumnsProvider {\n  const key = hashRawPool(rawPool);\n  let provider = _resultPoolProviderCache.get(key);\n  if (provider === undefined) {\n    provider = new ResultPoolColumnsProviderImpl(rawPool);\n    _resultPoolProviderCache.set(key, provider);\n  }\n  return provider;\n}\n\n/**\n * Simple provider wrapping an array of PColumns. Sandbox-only —\n * implements {@link ColumnsProvider} (lazy-view enumeration). It is *not* an\n * id-index source — `ColumnRegistry` does not consume it.\n */\nexport class ArrayColumnsProvider implements ColumnsProvider {\n  private readonly columns: DataColumnRecipe<PObjectId>[];\n\n  constructor(\n    columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | DataColumnRecipe<PObjectId>>,\n    private readonly _isFinal: boolean,\n  ) {\n    this.columns = columns.map((c) => DataColumn.fromColumn(c));\n  }\n\n  getColumns(): DataColumnRecipe<PObjectId>[] {\n    return this.columns;\n  }\n\n  isFinal(): boolean {\n    return this._isFinal;\n  }\n}\n\n/**\n * Sandbox-specific provider over a {@link TreeNodeAccessor} root. Uses the\n * accessor's own `resolvePath` as the canonical root path for id construction,\n * and adds `getColumns()` returning {@link DataColumnRecipe<PObjectId>}s on top of the generic\n * entries index.\n */\nexport class AccessorColumnsProviderImpl\n  extends AccessorEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: DataColumnRecipe<PObjectId>[];\n\n  constructor(root: TreeNodeAccessor) {\n    super(root, root.resolvePath);\n  }\n\n  getColumns(): DataColumnRecipe<PObjectId>[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(this.entries.values(), DataColumn.fromAccessor).filter(\n      (column) => column !== undefined,\n    ));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type AccessorColumnsProvider = AccessorColumnsProviderImpl;\n\n/**\n * Sandbox-specific result-pool provider. Accepts the raw handle-shaped blocks\n * returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx} and\n * wraps them into {@link TreeNodeAccessor}s, then adds `getColumns()`.\n */\nexport class ResultPoolColumnsProviderImpl\n  extends ResultPoolEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: DataColumnRecipe<PObjectId>[];\n\n  constructor(\n    rawPool: ReadonlyArray<\n      UpstreamBlockCtx<AccessorHandle>\n    > = getCfgRenderCtx().getUpstreamBlockCtx(),\n  ) {\n    const blocks = rawPool.map((b) => ({\n      blockId: b.blockId,\n      prodCtx:\n        b.prodCtx !== undefined\n          ? new TreeNodeAccessor(b.prodCtx, [b.blockId, \"prodCtx\"])\n          : undefined,\n      stagingCtx:\n        b.stagingCtx !== undefined\n          ? new TreeNodeAccessor(b.stagingCtx, [b.blockId, \"stagingCtx\"])\n          : undefined,\n      prodIncomplete: b.prodIncomplete,\n      stagingIncomplete: b.stagingIncomplete,\n    }));\n\n    super(blocks);\n  }\n\n  getColumns(): DataColumnRecipe<PObjectId>[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(\n      this.getPObjectEntries().values(),\n      DataColumn.fromAccessor,\n    ).filter((column) => column !== undefined));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type ResultPoolColumnsProvider = ResultPoolColumnsProviderImpl;\n\nfunction hashRawPool(rawPool: ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>): string {\n  return rawPool\n    .map(\n      (b) =>\n        `${b.blockId}\\x1f${b.prodCtx ?? \"\"}\\x1f${b.stagingCtx ?? \"\"}\\x1f${\n          b.prodIncomplete ? 1 : 0\n        }\\x1f${b.stagingIncomplete ? 1 : 0}`,\n    )\n    .join(\"\\x1e\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,gBACd,QACA;CACA,KAAA,GAAIA,WAAAA,MAAAA,CAAM,MAAM,KAAK,MAAM,QAAQ,MAAM,GACvC,OAAO,0BAA0B,MAAM;MAClC,IAAI,kBAAkBC,iBAAAA,kBAC3B,OAAO,wBAAwB,MAAM;MAErC,MAAM,IAAI,MAAM,iCAAiC;AAErD;;;;;;AAOA,MAAM,yBAAyB,IAAIC,UAAAA,SAAsD,EACvF,KAAK,GACP,CAAC;AACD,SAAgB,wBAAwB,MAAiD;CACvF,IAAI,WAAW,uBAAuB,IAAI,KAAK,MAAM;CACrD,IAAI,aAAa,KAAA,GAAW;EAC1B,WAAW,IAAI,4BAA4B,IAAI;EAC/C,uBAAuB,IAAI,KAAK,QAAQ,QAAQ;CAClD;CACA,OAAO;AACT;;;;;;AAOA,MAAM,2BAA2B,IAAIA,UAAAA,SAAgD,EAAE,KAAK,EAAE,CAAC;AAC/F,SAAgB,0BACd,UAEIC,iBAAAA,gBAAgB,CAAC,CAAC,oBAAoB,GACf;CAC3B,MAAM,MAAM,YAAY,OAAO;CAC/B,IAAI,WAAW,yBAAyB,IAAI,GAAG;CAC/C,IAAI,aAAa,KAAA,GAAW;EAC1B,WAAW,IAAI,8BAA8B,OAAO;EACpD,yBAAyB,IAAI,KAAK,QAAQ;CAC5C;CACA,OAAO;AACT;;;;;;AAOA,IAAa,uBAAb,MAA6D;CAKxC;CAJnB;CAEA,YACE,SACA,UACA;EADiB,KAAA,WAAA;EAEjB,KAAK,UAAU,QAAQ,KAAK,MAAMC,oBAAAA,WAAW,WAAW,CAAC,CAAC;CAC5D;CAEA,aAA4C;EAC1C,OAAO,KAAK;CACd;CAEA,UAAmB;EACjB,OAAO,KAAK;CACd;AACF;;;;;;;AAQA,IAAa,8BAAb,cACUC,gCAAAA,wBAEV;CACE;CAEA,YAAY,MAAwB;EAClC,MAAM,MAAM,KAAK,WAAW;CAC9B;CAEA,aAA4C;EAC1C,IAAI,KAAK,kBAAkB,KAAA,GAAW,OAAO,KAAK;EAClD,OAAQ,KAAK,gBAAgB,MAAM,KAAK,KAAK,QAAQ,OAAO,GAAGD,oBAAAA,WAAW,YAAY,CAAC,CAAC,QACrF,WAAW,WAAW,KAAA,CACzB;CACF;AACF;;;;;;AAUA,IAAa,gCAAb,cACUE,gCAAAA,0BAEV;CACE;CAEA,YACE,UAEIH,iBAAAA,gBAAgB,CAAC,CAAC,oBAAoB,GAC1C;EACA,MAAM,SAAS,QAAQ,KAAK,OAAO;GACjC,SAAS,EAAE;GACX,SACE,EAAE,YAAY,KAAA,IACV,IAAIF,iBAAAA,iBAAiB,EAAE,SAAS,CAAC,EAAE,SAAS,SAAS,CAAC,IACtD,KAAA;GACN,YACE,EAAE,eAAe,KAAA,IACb,IAAIA,iBAAAA,iBAAiB,EAAE,YAAY,CAAC,EAAE,SAAS,YAAY,CAAC,IAC5D,KAAA;GACN,gBAAgB,EAAE;GAClB,mBAAmB,EAAE;EACvB,EAAE;EAEF,MAAM,MAAM;CACd;CAEA,aAA4C;EAC1C,IAAI,KAAK,kBAAkB,KAAA,GAAW,OAAO,KAAK;EAClD,OAAQ,KAAK,gBAAgB,MAAM,KACjC,KAAK,kBAAkB,CAAC,CAAC,OAAO,GAChCG,oBAAAA,WAAW,YACb,CAAC,CAAC,QAAQ,WAAW,WAAW,KAAA,CAAS;CAC3C;AACF;AAKA,SAAS,YAAY,SAAkE;CACrF,OAAO,QACJ,KACE,MACC,GAAG,EAAE,QAAQ,MAAM,EAAE,WAAW,GAAG,MAAM,EAAE,cAAc,GAAG,MAC1D,EAAE,iBAAiB,IAAI,EACxB,MAAM,EAAE,oBAAoB,IAAI,GACrC,CAAC,CACA,KAAK,GAAM;AAChB"}