@platforma-sdk/model 1.80.13 → 1.81.0

package/dist/columns/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["ColumnLazyImpl","TreeNodeAccessor","ColumnDiscoveredRecipe","ColumnOverriddenRecipe","ColumnFilteredRecipe","isColumnsCollection","ColumnsCollection","deriveDistinctLabels"],"sources":["../../src/columns/utils.ts"],"sourcesContent":["import {\n  collectSpecQueryColumns,\n  extractPObjectId,\n  isDataInfo,\n  visitDataInfo,\n  type AxisQualification,\n  type ColumnUniversalId,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport { throwError } from \"@milaboratories/helpers\";\nimport type { GlobalCfgRenderCtx } from \"../render/internal\";\nimport { TreeNodeAccessor } from \"../render\";\nimport { deriveDistinctLabels, type DeriveLabelsOptions } from \"../labels/derive_distinct_labels\";\nimport { ColumnLazy, ColumnLazyImpl, type ColumnLazyData } from \"./column_lazy\";\nimport { ColumnDiscoveredRecipe } from \"./column_recipes/column_discovered_recipe\";\nimport { ColumnFilteredRecipe } from \"./column_recipes/column_filtered_recipe\";\nimport { ColumnOverriddenRecipe } from \"./column_recipes/column_overrided_recipe\";\nimport type { ColumnRecipe } from \"./column_recipes/types\";\nimport { ColumnsCollection, isColumnsCollection } from \"./columns_collection\";\nimport type { ColumnsSource } from \"./column_providers/types\";\n\n/**\n * PObjectIds of every non-hit column referenced by `recipe.getQuery()`,\n * deduped in traversal order. The hit column is\n * `extractPObjectId(recipe.id)`; anything else in the query is a linker or\n * other engine-consumed column.\n *\n * Pure query walk — no registry access. Use {@link collectLinkerColumns} for\n * the resolved {@link ColumnLazy} variant.\n */\nexport function collectLinkerIds(recipe: ColumnRecipe): PObjectId[] {\n  const hit = extractPObjectId(recipe.id);\n  const seen = new Set<PObjectId>();\n  const out: PObjectId[] = [];\n  for (const id of collectSpecQueryColumns(recipe.getQuery())) {\n    // Leaf ids in SpecQuery may be rich (e.g. ColumnDiscoveredId) — drop to\n    // bare PObjectId before comparing/registering so we hand the ambient\n    // ColumnRegistry physical ids it can resolve.\n    const bare = extractPObjectId(id);\n    if (bare === hit) continue;\n    if (seen.has(bare)) continue;\n    seen.add(bare);\n    out.push(bare);\n  }\n  return out;\n}\n\n/**\n * {@link collectLinkerIds} resolved against the ambient context as\n * {@link ColumnLazy} instances. Throws if any id fails to resolve —\n * matches the contract of the legacy `resolveLinkers` it replaces.\n */\nexport function collectLinkerColumns(\n  recipe: ColumnRecipe,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): ColumnLazy[] {\n  return collectLinkerIds(recipe).map(\n    (id) =>\n      ColumnLazyImpl.fromId(id, opts) ??\n      throwError(`materializeLinkers: linker ${id} not resolvable`),\n  );\n}\n\n/**\n * Hit-side axis qualifications for the recipe — the ones that should land on\n * the outer-join entry wrapping this column at the consumer boundary.\n *\n * Descends {@link ColumnOverriddenRecipe} / {@link ColumnFilteredRecipe} via\n * `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise\n * returns `[]`. Pure recipe walk — no query-tree introspection.\n */\nexport function hitQualifications(recipe: ColumnRecipe): readonly AxisQualification[] {\n  const discovered = findDiscovered(recipe);\n  return discovered?.getColumnQualifications() ?? [];\n}\n\n/**\n * Per-primary-column axis qualifications for the recipe — applied to the\n * outer primary anchors on this recipe's group side. Keyed by the external\n * primary column id (NOT by columns inside this recipe's own query).\n *\n * Same walk strategy as {@link hitQualifications}.\n */\nexport function queriesQualifications(\n  recipe: ColumnRecipe,\n): Readonly<Record<PObjectId, AxisQualification[]>> {\n  const discovered = findDiscovered(recipe);\n  return discovered?.getQueriesQualifications() ?? {};\n}\n\n/**\n * Whether the recipe's underlying data resources actually carry bytes —\n * strictly stronger than `getDataStatus() === \"present\"`, which only tells\n * that the `.data` field is wired onto the accessor.\n *\n * Walks every physical leaf the recipe depends on via\n * {@link ColumnRecipe.getReferencedIds} (resolves each id back to a\n * {@link ColumnLazy} through the ambient ctx) and ANDs `hasData()` across\n * all of them. Inline {@link PColumnValues} payloads count as present.\n *\n * Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as\n * \"not yet ready\") rather than throwing — this is a UI-facing predicate, not\n * a contract assertion.\n */\nexport function hasColumnData(\n  recipe: ColumnRecipe,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): boolean {\n  for (const id of recipe.getReferencedIds()) {\n    const lazy = ColumnLazyImpl.fromId(id, opts);\n    if (lazy === undefined) return false;\n    if (lazy.getDataStatus() !== \"present\") return false;\n    if (!isLazyDataPresent(lazy.getData())) return false;\n  }\n  return true;\n}\n\nfunction isLazyDataPresent(data: ColumnLazyData): boolean {\n  if (data === undefined) return false;\n  if (Array.isArray(data)) return true;\n  if (data instanceof TreeNodeAccessor) return data.hasData();\n  if (isDataInfo(data)) {\n    let ok = true;\n    visitDataInfo(data, (blob) => {\n      ok &&= blob.hasData();\n    });\n    return ok;\n  }\n  return false;\n}\n\n/**\n * Walk wrapper layers (Overridden, Filtered) until a {@link\n * ColumnDiscoveredRecipe} is found. Returns `undefined` if the recipe chain\n * has no Discovered layer (bare leaves and Overridden-over-leaf cases).\n *\n * Invariant from the wrapper classes themselves: there is at most one\n * Discovered layer in any recipe chain — Discovered is constructed only via\n * its own factory and is never re-wrapped by Discovered.\n */\nfunction findDiscovered(recipe: ColumnRecipe): undefined | ColumnDiscoveredRecipe {\n  let current: ColumnRecipe = recipe;\n  while (true) {\n    if (current instanceof ColumnDiscoveredRecipe) return current;\n    if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {\n      current = current.getInner();\n      continue;\n    }\n    return undefined;\n  }\n}\n\n/**\n * A recipe is a \"leaf\" (directly co-indexed on the anchor, reached without a\n * linker chain) iff its wrapper chain contains no {@link ColumnDiscoveredRecipe}.\n *\n * `Filtered` / `Overridden` over a bare leaf stay leaves; anything wrapping a\n * `Discovered` (e.g. `Overridden(Discovered(...))`) is linked. Use this — not an\n * `instanceof ColumnLazyImpl` check — to split direct vs. linker-joined columns,\n * since projections over a plain leaf are still direct.\n */\nexport function isLeafColumn(recipe: ColumnRecipe): boolean {\n  return findDiscovered(recipe) === undefined;\n}\n\n/**\n * Data of the bare leaf a \"leaf\" recipe bottoms out at — reads the leaf-only\n * {@link ColumnLazy.getData} after walking the wrapper chain down via\n * {@link extractLeafColumn}. Returns `undefined` when the recipe is not a leaf (its\n * chain reaches a {@link ColumnDiscoveredRecipe}); the symmetric counterpart\n * of {@link isLeafColumn} returning `false`.\n */\nexport function getLeafColumnData(recipe: ColumnRecipe): ColumnLazyData {\n  if (!isLeafColumn(recipe)) {\n    throw new Error(`getLeafColumnData: recipe ${recipe.id} is not a leaf column`);\n  }\n  return extractLeafColumn(recipe)?.getData();\n}\n\n/**\n * Walk wrapper layers (Overridden, Filtered) down to the bare {@link ColumnLazy}\n * leaf the chain bottoms out at. Returns `undefined` if the chain reaches a\n * {@link ColumnDiscoveredRecipe} instead — i.e. the recipe is not a leaf\n * ({@link isLeafColumn} would return `false`). Mirror of {@link findDiscovered}.\n */\nfunction extractLeafColumn(recipe: ColumnRecipe): undefined | ColumnLazy {\n  let current: ColumnRecipe = recipe;\n  while (true) {\n    if (current instanceof ColumnLazyImpl) return current;\n    if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {\n      current = current.getInner();\n      continue;\n    }\n    if (current instanceof ColumnDiscoveredRecipe) {\n      throw new Error(`extractLeafColumn: recipe ${recipe.id} is not a leaf column`);\n    }\n    throw new Error(`extractLeafColumn: unrecognized recipe layer for ${recipe.id}`);\n  }\n}\n\n/** Drop-down option built over a {@link ColumnsCollection} — universal-id valued. */\nexport type ColumnOption = {\n  readonly id: ColumnUniversalId;\n  readonly label: string;\n};\n\n/**\n * Enumerates every column already in `source` and renders distinct labels\n * from each recipe's spec. Filtering is the caller's job — pass a\n * {@link ColumnsCollection} that was already narrowed via `.filter(...)` /\n * `.discover(...)`, or hand over a raw {@link ColumnsSource} (provider,\n * accessor, column array, or `\"result_pool\"` / `\"current_block\"` shorthand)\n * to be wrapped on the fly.\n */\nexport function deriveColumnOptions(\n  source: ColumnsCollection | ColumnsSource[],\n  labelOptions: DeriveLabelsOptions = {},\n): ColumnOption[] {\n  const collection = isColumnsCollection(source) ? source : ColumnsCollection(source);\n  const recipes = collection.getColumns();\n  const labels = deriveDistinctLabels(\n    recipes.map((r) => r.getSpec()),\n    labelOptions,\n  );\n  return recipes.map((r, i) => ({ id: r.id, label: labels[i] }));\n}\n"],"mappings":"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"}
+{"version":3,"file":"utils.cjs","names":["DataColumnImpl","TreeNodeAccessor","ColumnDiscoveredRecipe","ColumnOverriddenRecipe","ColumnFilteredRecipe","DataColumnOverriddenRecipe","isColumnsCollection","ColumnsCollection","deriveDistinctLabels"],"sources":["../../src/columns/utils.ts"],"sourcesContent":["import {\n  collectSpecQueryColumns,\n  extractPObjectId,\n  isDataInfo,\n  visitDataInfo,\n  type AxisQualification,\n  type ColumnUniversalId,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport { throwError } from \"@milaboratories/helpers\";\nimport type { GlobalCfgRenderCtx } from \"../render/internal\";\nimport { TreeNodeAccessor } from \"../render\";\nimport { deriveDistinctLabels, type DeriveLabelsOptions } from \"../labels/derive_distinct_labels\";\nimport { DataColumnRecipe, DataColumnImpl, type ColumnData } from \"./data_column\";\nimport { ColumnDiscoveredRecipe } from \"./column_recipes/column_discovered_recipe\";\nimport { ColumnFilteredRecipe } from \"./column_recipes/column_filtered_recipe\";\nimport {\n  ColumnOverriddenRecipe,\n  DataColumnOverriddenRecipe,\n} from \"./column_recipes/column_overrided_recipe\";\nimport type { ColumnRecipe } from \"./column_recipes/types\";\nimport { ColumnsCollection, isColumnsCollection } from \"./columns_collection\";\nimport type { ColumnsSource } from \"./column_providers/types\";\n\n/**\n * PObjectIds of every non-hit column referenced by `recipe.getQuery()`,\n * deduped in traversal order. The hit column is\n * `extractPObjectId(recipe.id)`; anything else in the query is a linker or\n * other engine-consumed column.\n *\n * Pure query walk — no registry access. Use {@link collectLinkerColumns} for\n * the resolved {@link DataColumnRecipe} variant.\n */\nexport function collectLinkerIds(recipe: ColumnRecipe): PObjectId[] {\n  const hit = extractPObjectId(recipe.id);\n  const seen = new Set<PObjectId>();\n  const out: PObjectId[] = [];\n  for (const id of collectSpecQueryColumns(recipe.getQuery())) {\n    // Leaf ids in SpecQuery may be rich (e.g. ColumnDiscoveredId) — drop to\n    // bare PObjectId before comparing/registering so we hand the ambient\n    // ColumnRegistry physical ids it can resolve.\n    const bare = extractPObjectId(id);\n    if (bare === hit) continue;\n    if (seen.has(bare)) continue;\n    seen.add(bare);\n    out.push(bare);\n  }\n  return out;\n}\n\n/**\n * {@link collectLinkerIds} resolved against the ambient context as\n * {@link DataColumnRecipe} leaves. Throws if any id fails to resolve —\n * matches the contract of the legacy `resolveLinkers` it replaces.\n */\nexport function collectLinkerColumns(\n  recipe: ColumnRecipe,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): DataColumnRecipe<PObjectId>[] {\n  return collectLinkerIds(recipe).map(\n    (id) =>\n      DataColumnImpl.fromId(id, opts) ??\n      throwError(`materializeLinkers: linker ${id} not resolvable`),\n  );\n}\n\n/**\n * Hit-side axis qualifications for the recipe — the ones that should land on\n * the outer-join entry wrapping this column at the consumer boundary.\n *\n * Descends {@link ColumnOverriddenRecipe} / {@link ColumnFilteredRecipe} via\n * `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise\n * returns `[]`. Pure recipe walk — no query-tree introspection.\n */\nexport function hitQualifications(recipe: ColumnRecipe): readonly AxisQualification[] {\n  const discovered = findDiscovered(recipe);\n  return discovered?.getColumnQualifications() ?? [];\n}\n\n/**\n * Per-primary-column axis qualifications for the recipe — applied to the\n * outer primary anchors on this recipe's group side. Keyed by the external\n * primary column id (NOT by columns inside this recipe's own query).\n *\n * Same walk strategy as {@link hitQualifications}.\n */\nexport function queriesQualifications(\n  recipe: ColumnRecipe,\n): Readonly<Record<PObjectId, AxisQualification[]>> {\n  const discovered = findDiscovered(recipe);\n  return discovered?.getQueriesQualifications() ?? {};\n}\n\n/**\n * Whether the recipe's underlying data resources actually carry bytes —\n * strictly stronger than `getDataStatus() === \"present\"`, which only tells\n * that the `.data` field is wired onto the accessor.\n *\n * Walks every physical leaf the recipe depends on via\n * {@link ColumnRecipe.getReferencedIds} (resolves each id back to a\n * {@link DataColumnRecipe} through the ambient ctx) and ANDs `hasData()` across\n * all of them. Inline {@link PColumnValues} payloads count as present.\n *\n * Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as\n * \"not yet ready\") rather than throwing — this is a UI-facing predicate, not\n * a contract assertion.\n */\nexport function hasColumnData(\n  recipe: ColumnRecipe,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): boolean {\n  for (const id of recipe.getReferencedIds()) {\n    const leaf = DataColumnImpl.fromId(id, opts);\n    if (leaf === undefined) return false;\n    if (leaf.getDataStatus() !== \"present\") return false;\n    if (!isLeafDataPresent(leaf.getData())) return false;\n  }\n  return true;\n}\n\nfunction isLeafDataPresent(data: ColumnData): boolean {\n  if (data === undefined) return false;\n  if (Array.isArray(data)) return true;\n  if (data instanceof TreeNodeAccessor) return data.hasData();\n  if (isDataInfo(data)) {\n    let ok = true;\n    visitDataInfo(data, (blob) => {\n      ok &&= blob.hasData();\n    });\n    return ok;\n  }\n  return false;\n}\n\n/**\n * Walk wrapper layers (Overridden, Filtered) until a {@link\n * ColumnDiscoveredRecipe} is found. Returns `undefined` if the recipe chain\n * has no Discovered layer (bare leaves and Overridden-over-leaf cases).\n *\n * Invariant from the wrapper classes themselves: there is at most one\n * Discovered layer in any recipe chain — Discovered is constructed only via\n * its own factory and is never re-wrapped by Discovered.\n */\nfunction findDiscovered(recipe: ColumnRecipe): undefined | ColumnDiscoveredRecipe {\n  let current: ColumnRecipe = recipe;\n  while (true) {\n    if (current instanceof ColumnDiscoveredRecipe) return current;\n    if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {\n      current = current.getInner();\n      continue;\n    }\n    return undefined;\n  }\n}\n\n/**\n * Whether the recipe reads exactly one data column — its own — rather than\n * reaching through others.\n *\n * True for a bare leaf and for projections over one (spec overrides, axis\n * slicing): those add layers but no new columns. False when the recipe gets at\n * its data through further columns, which happens when discovery reached it via\n * a linker chain.\n *\n * **Why callers care.** A recipe over a single data column is co-indexed by its\n * own axes, so its spec is the whole truth about them. One that needs other\n * columns only lines up after they are joined in, and therefore drags axes into\n * the join that its own spec never mentions — which is why it cannot serve as a\n * primary column, and why `createPlDataTableV3` splits on this.\n *\n * The count comes from {@link ColumnRecipe.getReferencedIds}, which resolves\n * through the whole wrapper chain, so no class walk is involved and foreign\n * `ColumnRecipe` implementations are handled too.\n */\nexport function hasSingleDataColumn(recipe: ColumnRecipe): boolean {\n  return recipe.getReferencedIds().length === 1;\n}\n\n/**\n * @deprecated Renamed to {@link hasSingleDataColumn} — \"leaf\" read as \"you can\n * get data out of it\", which is a different question (see\n * {@link hasReachableData}). Same semantics.\n */\nexport const isLeafColumn = hasSingleDataColumn;\n\n/**\n * Whether the column's data can be read here and now, consistent with its\n * spec — narrows to {@link DataColumnRecipe}, which exposes `getData()`.\n *\n * True for a bare leaf and for a spec-override over a bare leaf. False for an\n * axis-filtered recipe (its spec has dropped axes the underlying data still\n * carries, so the two no longer line up) and for anything reached through\n * other columns (nothing to read until the engine joins them). In both of\n * those cases the data exists only engine-side: pass `recipe.id` to\n * `createPFrame` / `createPTable` instead of trying to read it.\n *\n * The distinction is settled when the recipe is built, not here — recipes that\n * carry data are instances of a class that declares `getData`. So a `true`\n * result narrows to a value that really has the method, and there is no\n * throwing path behind the guard.\n */\nexport function hasReachableData(recipe: ColumnRecipe): recipe is DataColumnRecipe {\n  return recipe instanceof DataColumnImpl || recipe instanceof DataColumnOverriddenRecipe;\n}\n\n/** Drop-down option built over a {@link ColumnsCollection} — universal-id valued. */\nexport type ColumnOption = {\n  readonly id: ColumnUniversalId;\n  readonly label: string;\n};\n\n/**\n * Enumerates every column already in `source` and renders distinct labels\n * from each recipe's spec. Filtering is the caller's job — pass a\n * {@link ColumnsCollection} that was already narrowed via `.filter(...)` /\n * `.discover(...)`, or hand over a raw {@link ColumnsSource} (provider,\n * accessor, column array, or `\"result_pool\"` / `\"current_block\"` shorthand)\n * to be wrapped on the fly.\n */\nexport function deriveColumnOptions(\n  source: ColumnsCollection | ColumnsSource[],\n  labelOptions: DeriveLabelsOptions = {},\n): ColumnOption[] {\n  const collection = isColumnsCollection(source) ? source : ColumnsCollection(source);\n  const recipes = collection.getColumns();\n  const labels = deriveDistinctLabels(\n    recipes.map((r) => r.getSpec()),\n    labelOptions,\n  );\n  return recipes.map((r, i) => ({ id: r.id, label: labels[i] }));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,iBAAiB,QAAmC;CAClE,MAAM,OAAA,GAAA,gCAAA,iBAAA,CAAuB,OAAO,EAAE;CACtC,MAAM,uBAAO,IAAI,IAAe;CAChC,MAAM,MAAmB,CAAC;CAC1B,KAAK,MAAM,OAAA,GAAA,gCAAA,wBAAA,CAA8B,OAAO,SAAS,CAAC,GAAG;EAI3D,MAAM,QAAA,GAAA,gCAAA,iBAAA,CAAwB,EAAE;EAChC,IAAI,SAAS,KAAK;EAClB,IAAI,KAAK,IAAI,IAAI,GAAG;EACpB,KAAK,IAAI,IAAI;EACb,IAAI,KAAK,IAAI;CACf;CACA,OAAO;AACT;;;;;;AAOA,SAAgB,qBACd,QACA,OAAqC,CAAC,GACP;CAC/B,OAAO,iBAAiB,MAAM,CAAC,CAAC,KAC7B,OACCA,oBAAAA,eAAe,OAAO,IAAI,IAAI,MAAA,GAAA,wBAAA,WAAA,CACnB,8BAA8B,GAAG,gBAAgB,CAChE;AACF;;;;;;;;;AAUA,SAAgB,kBAAkB,QAAoD;CAEpF,OADmB,eAAe,MAClB,CAAC,EAAE,wBAAwB,KAAK,CAAC;AACnD;;;;;;;;AASA,SAAgB,sBACd,QACkD;CAElD,OADmB,eAAe,MAClB,CAAC,EAAE,yBAAyB,KAAK,CAAC;AACpD;;;;;;;;;;;;;;;AAgBA,SAAgB,cACd,QACA,OAAqC,CAAC,GAC7B;CACT,KAAK,MAAM,MAAM,OAAO,iBAAiB,GAAG;EAC1C,MAAM,OAAOA,oBAAAA,eAAe,OAAO,IAAI,IAAI;EAC3C,IAAI,SAAS,KAAA,GAAW,OAAO;EAC/B,IAAI,KAAK,cAAc,MAAM,WAAW,OAAO;EAC/C,IAAI,CAAC,kBAAkB,KAAK,QAAQ,CAAC,GAAG,OAAO;CACjD;CACA,OAAO;AACT;AAEA,SAAS,kBAAkB,MAA2B;CACpD,IAAI,SAAS,KAAA,GAAW,OAAO;CAC/B,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO;CAChC,IAAI,gBAAgBC,iBAAAA,kBAAkB,OAAO,KAAK,QAAQ;CAC1D,KAAA,GAAA,gCAAA,WAAA,CAAe,IAAI,GAAG;EACpB,IAAI,KAAK;EACT,CAAA,GAAA,gCAAA,cAAA,CAAc,OAAO,SAAS;GAC5B,OAAO,KAAK,QAAQ;EACtB,CAAC;EACD,OAAO;CACT;CACA,OAAO;AACT;;;;;;;;;;AAWA,SAAS,eAAe,QAA0D;CAChF,IAAI,UAAwB;CAC5B,OAAO,MAAM;EACX,IAAI,mBAAmBC,iCAAAA,wBAAwB,OAAO;EACtD,IAAI,mBAAmBC,gCAAAA,0BAA0B,mBAAmBC,+BAAAA,sBAAsB;GACxF,UAAU,QAAQ,SAAS;GAC3B;EACF;EACA;CACF;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,oBAAoB,QAA+B;CACjE,OAAO,OAAO,iBAAiB,CAAC,CAAC,WAAW;AAC9C;;;;;;AAOA,MAAa,eAAe;;;;;;;;;;;;;;;;;AAkB5B,SAAgB,iBAAiB,QAAkD;CACjF,OAAO,kBAAkBJ,oBAAAA,kBAAkB,kBAAkBK,gCAAAA;AAC/D;;;;;;;;;AAgBA,SAAgB,oBACd,QACA,eAAoC,CAAC,GACrB;CAEhB,MAAM,WADaC,2BAAAA,oBAAoB,MAAM,IAAI,SAASC,2BAAAA,kBAAkB,MAAM,EAAA,CACvD,WAAW;CACtC,MAAM,SAASC,+BAAAA,qBACb,QAAQ,KAAK,MAAM,EAAE,QAAQ,CAAC,GAC9B,YACF;CACA,OAAO,QAAQ,KAAK,GAAG,OAAO;EAAE,IAAI,EAAE;EAAI,OAAO,OAAO;CAAG,EAAE;AAC/D"}

package/dist/columns/utils.d.ts

@@ -1,7 +1,7 @@
 import { GlobalCfgRenderCtx } from "../render/internal.js";
 import { DeriveLabelsOptions } from "../labels/derive_distinct_labels.js";
 import { ColumnRecipe } from "./column_recipes/types.js";
-import { ColumnLazy, ColumnLazyData } from "./column_lazy.js";
+import { DataColumnRecipe } from "./data_column.js";
 import { ColumnsSource } from "./column_providers/types.js";
 import { ColumnsCollection } from "./columns_collection.js";
 import { AxisQualification, ColumnUniversalId, PObjectId } from "@milaboratories/pl-model-common";
@@ -14,17 +14,17 @@ import { AxisQualification, ColumnUniversalId, PObjectId } from "@milaboratories
  * other engine-consumed column.
  *
  * Pure query walk — no registry access. Use {@link collectLinkerColumns} for
- * the resolved {@link ColumnLazy} variant.
+ * the resolved {@link DataColumnRecipe} variant.
  */
 declare function collectLinkerIds(recipe: ColumnRecipe): PObjectId[];
 /**
  * {@link collectLinkerIds} resolved against the ambient context as
- * {@link ColumnLazy} instances. Throws if any id fails to resolve —
+ * {@link DataColumnRecipe} leaves. Throws if any id fails to resolve —
  * matches the contract of the legacy `resolveLinkers` it replaces.
  */
 declare function collectLinkerColumns(recipe: ColumnRecipe, opts?: {
   ctx?: GlobalCfgRenderCtx;
-}): ColumnLazy[];
+}): DataColumnRecipe<PObjectId>[];
 /**
  * Hit-side axis qualifications for the recipe — the ones that should land on
  * the outer-join entry wrapping this column at the consumer boundary.
@@ -49,7 +49,7 @@ declare function queriesQualifications(recipe: ColumnRecipe): Readonly<Record<PO
  *
  * Walks every physical leaf the recipe depends on via
  * {@link ColumnRecipe.getReferencedIds} (resolves each id back to a
- * {@link ColumnLazy} through the ambient ctx) and ANDs `hasData()` across
+ * {@link DataColumnRecipe} through the ambient ctx) and ANDs `hasData()` across
  * all of them. Inline {@link PColumnValues} payloads count as present.
  *
  * Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as
@@ -60,23 +60,48 @@ declare function hasColumnData(recipe: ColumnRecipe, opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): boolean;
 /**
- * A recipe is a "leaf" (directly co-indexed on the anchor, reached without a
- * linker chain) iff its wrapper chain contains no {@link ColumnDiscoveredRecipe}.
+ * Whether the recipe reads exactly one data column — its own — rather than
+ * reaching through others.
  *
- * `Filtered` / `Overridden` over a bare leaf stay leaves; anything wrapping a
- * `Discovered` (e.g. `Overridden(Discovered(...))`) is linked. Use this — not an
- * `instanceof ColumnLazyImpl` check — to split direct vs. linker-joined columns,
- * since projections over a plain leaf are still direct.
+ * True for a bare leaf and for projections over one (spec overrides, axis
+ * slicing): those add layers but no new columns. False when the recipe gets at
+ * its data through further columns, which happens when discovery reached it via
+ * a linker chain.
+ *
+ * **Why callers care.** A recipe over a single data column is co-indexed by its
+ * own axes, so its spec is the whole truth about them. One that needs other
+ * columns only lines up after they are joined in, and therefore drags axes into
+ * the join that its own spec never mentions — which is why it cannot serve as a
+ * primary column, and why `createPlDataTableV3` splits on this.
+ *
+ * The count comes from {@link ColumnRecipe.getReferencedIds}, which resolves
+ * through the whole wrapper chain, so no class walk is involved and foreign
+ * `ColumnRecipe` implementations are handled too.
+ */
+declare function hasSingleDataColumn(recipe: ColumnRecipe): boolean;
+/**
+ * @deprecated Renamed to {@link hasSingleDataColumn} — "leaf" read as "you can
+ * get data out of it", which is a different question (see
+ * {@link hasReachableData}). Same semantics.
  */
-declare function isLeafColumn(recipe: ColumnRecipe): boolean;
+declare const isLeafColumn: typeof hasSingleDataColumn;
 /**
- * Data of the bare leaf a "leaf" recipe bottoms out at — reads the leaf-only
- * {@link ColumnLazy.getData} after walking the wrapper chain down via
- * {@link extractLeafColumn}. Returns `undefined` when the recipe is not a leaf (its
- * chain reaches a {@link ColumnDiscoveredRecipe}); the symmetric counterpart
- * of {@link isLeafColumn} returning `false`.
+ * Whether the column's data can be read here and now, consistent with its
+ * spec — narrows to {@link DataColumnRecipe}, which exposes `getData()`.
+ *
+ * True for a bare leaf and for a spec-override over a bare leaf. False for an
+ * axis-filtered recipe (its spec has dropped axes the underlying data still
+ * carries, so the two no longer line up) and for anything reached through
+ * other columns (nothing to read until the engine joins them). In both of
+ * those cases the data exists only engine-side: pass `recipe.id` to
+ * `createPFrame` / `createPTable` instead of trying to read it.
+ *
+ * The distinction is settled when the recipe is built, not here — recipes that
+ * carry data are instances of a class that declares `getData`. So a `true`
+ * result narrows to a value that really has the method, and there is no
+ * throwing path behind the guard.
  */
-declare function getLeafColumnData(recipe: ColumnRecipe): ColumnLazyData;
+declare function hasReachableData(recipe: ColumnRecipe): recipe is DataColumnRecipe;
 /** Drop-down option built over a {@link ColumnsCollection} — universal-id valued. */
 type ColumnOption = {
   readonly id: ColumnUniversalId;
@@ -92,5 +117,5 @@ type ColumnOption = {
  */
 declare function deriveColumnOptions(source: ColumnsCollection | ColumnsSource[], labelOptions?: DeriveLabelsOptions): ColumnOption[];
 //#endregion
-export { ColumnOption, collectLinkerColumns, collectLinkerIds, deriveColumnOptions, getLeafColumnData, hasColumnData, hitQualifications, isLeafColumn, queriesQualifications };
+export { ColumnOption, collectLinkerColumns, collectLinkerIds, deriveColumnOptions, hasColumnData, hasReachableData, hasSingleDataColumn, hitQualifications, isLeafColumn, queriesQualifications };
 //# sourceMappingURL=utils.d.ts.map

package/dist/columns/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/columns/utils.ts"],"mappings":";;;;;;;;;;;AA8BA;;;;;;;iBAAgB,gBAAA,CAAiB,MAAA,EAAQ,YAAA,GAAe,SAAS;AAAA;AAsBjE;;;;AAtBiE,iBAsBjD,oBAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,IACb,UAAA;;;;;;;;;iBAgBa,iBAAA,CAAkB,MAAA,EAAQ,YAAA,YAAwB,iBAAiB;AAAnF;;;;;;;AAAA,iBAYgB,qBAAA,CACd,MAAA,EAAQ,YAAA,GACP,QAAA,CAAS,MAAA,CAAO,SAAA,EAAW,iBAAA;AAdqD;AAYnF;;;;;;;;;;;;;AAZmF,iBAiCnE,aAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAkB;AAAA;;AArBa;AAmB/C;;;;;;;iBAyDgB,YAAA,CAAa,MAAoB,EAAZ,YAAY;;;AAvDR;AAuDzC;;;;iBAWgB,iBAAA,CAAkB,MAAA,EAAQ,YAAA,GAAe,cAAc;AAAvE;AAAA,KA6BY,YAAA;EAAA,SACD,EAAA,EAAI,iBAAiB;EAAA,SACrB,KAAA;AAAA;;;;AA/B4D;AA6BvE;;;;iBAagB,mBAAA,CACd,MAAA,EAAQ,iBAAA,GAAoB,aAAA,IAC5B,YAAA,GAAc,mBAAA,GACb,YAAA"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/columns/utils.ts"],"mappings":";;;;;;;;;;;AAiCA;;;;;;;iBAAgB,gBAAA,CAAiB,MAAA,EAAQ,YAAA,GAAe,SAAS;AAAA;AAsBjE;;;;AAtBiE,iBAsBjD,oBAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,IACb,gBAAA,CAAiB,SAAA;;;;;;;;;iBAgBJ,iBAAA,CAAkB,MAAA,EAAQ,YAAA,YAAwB,iBAAiB;;AAhBtD;AAgB7B;;;;;iBAYgB,qBAAA,CACd,MAAA,EAAQ,YAAA,GACP,QAAA,CAAS,MAAA,CAAO,SAAA,EAAW,iBAAA;;;AAdqD;AAYnF;;;;;;;;;;;iBAqBgB,aAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAkB;AAAA;;;;AArBa;AAmB/C;;;;;;;;;;AAEyC;AAiEzC;;;;iBAAgB,mBAAA,CAAoB,MAAoB,EAAZ,YAAY;AASxD;;;;AAA+C;AAA/C,cAAa,YAAA,SAAY,mBAAsB;;;;;;;;;AAkBmC;AAKlF;;;;;;;iBALgB,gBAAA,CAAiB,MAAA,EAAQ,YAAA,GAAe,MAAA,IAAU,gBAAgB;AAOlE;AAAA,KAFJ,YAAA;EAAA,SACD,EAAA,EAAI,iBAAiB;EAAA,SACrB,KAAA;AAAA;;;;;;;;;iBAWK,mBAAA,CACd,MAAA,EAAQ,iBAAA,GAAoB,aAAA,IAC5B,YAAA,GAAc,mBAAA,GACb,YAAA"}

package/dist/columns/utils.js

@@ -3,8 +3,8 @@ import { deriveDistinctLabels } from "../labels/derive_distinct_labels.js";
 import "../render/index.js";
 import { ColumnDiscoveredRecipe } from "./column_recipes/column_discovered_recipe.js";
 import { ColumnFilteredRecipe } from "./column_recipes/column_filtered_recipe.js";
-import { ColumnOverriddenRecipe } from "./column_recipes/column_overrided_recipe.js";
-import { ColumnLazyImpl } from "./column_lazy.js";
+import { ColumnOverriddenRecipe, DataColumnOverriddenRecipe } from "./column_recipes/column_overrided_recipe.js";
+import { DataColumnImpl } from "./data_column.js";
 import { ColumnsCollection, isColumnsCollection } from "./columns_collection.js";
 import { collectSpecQueryColumns, extractPObjectId, isDataInfo, visitDataInfo } from "@milaboratories/pl-model-common";
 import { throwError } from "@milaboratories/helpers";
@@ -16,7 +16,7 @@ import { throwError } from "@milaboratories/helpers";
 * other engine-consumed column.
 *
 * Pure query walk — no registry access. Use {@link collectLinkerColumns} for
-* the resolved {@link ColumnLazy} variant.
+* the resolved {@link DataColumnRecipe} variant.
 */
 function collectLinkerIds(recipe) {
 	const hit = extractPObjectId(recipe.id);
@@ -33,11 +33,11 @@ function collectLinkerIds(recipe) {
 }
 /**
 * {@link collectLinkerIds} resolved against the ambient context as
-* {@link ColumnLazy} instances. Throws if any id fails to resolve —
+* {@link DataColumnRecipe} leaves. Throws if any id fails to resolve —
 * matches the contract of the legacy `resolveLinkers` it replaces.
 */
 function collectLinkerColumns(recipe, opts = {}) {
-	return collectLinkerIds(recipe).map((id) => ColumnLazyImpl.fromId(id, opts) ?? throwError(`materializeLinkers: linker ${id} not resolvable`));
+	return collectLinkerIds(recipe).map((id) => DataColumnImpl.fromId(id, opts) ?? throwError(`materializeLinkers: linker ${id} not resolvable`));
 }
 /**
 * Hit-side axis qualifications for the recipe — the ones that should land on
@@ -67,7 +67,7 @@ function queriesQualifications(recipe) {
 *
 * Walks every physical leaf the recipe depends on via
 * {@link ColumnRecipe.getReferencedIds} (resolves each id back to a
-* {@link ColumnLazy} through the ambient ctx) and ANDs `hasData()` across
+* {@link DataColumnRecipe} through the ambient ctx) and ANDs `hasData()` across
 * all of them. Inline {@link PColumnValues} payloads count as present.
 *
 * Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as
@@ -76,14 +76,14 @@ function queriesQualifications(recipe) {
 */
 function hasColumnData(recipe, opts = {}) {
 	for (const id of recipe.getReferencedIds()) {
-		const lazy = ColumnLazyImpl.fromId(id, opts);
-		if (lazy === void 0) return false;
-		if (lazy.getDataStatus() !== "present") return false;
-		if (!isLazyDataPresent(lazy.getData())) return false;
+		const leaf = DataColumnImpl.fromId(id, opts);
+		if (leaf === void 0) return false;
+		if (leaf.getDataStatus() !== "present") return false;
+		if (!isLeafDataPresent(leaf.getData())) return false;
 	}
 	return true;
 }
-function isLazyDataPresent(data) {
+function isLeafDataPresent(data) {
 	if (data === void 0) return false;
 	if (Array.isArray(data)) return true;
 	if (data instanceof TreeNodeAccessor) return data.hasData();
@@ -117,45 +117,51 @@ function findDiscovered(recipe) {
 	}
 }
 /**
-* A recipe is a "leaf" (directly co-indexed on the anchor, reached without a
-* linker chain) iff its wrapper chain contains no {@link ColumnDiscoveredRecipe}.
+* Whether the recipe reads exactly one data column — its own — rather than
+* reaching through others.
 *
-* `Filtered` / `Overridden` over a bare leaf stay leaves; anything wrapping a
-* `Discovered` (e.g. `Overridden(Discovered(...))`) is linked. Use this — not an
-* `instanceof ColumnLazyImpl` check — to split direct vs. linker-joined columns,
-* since projections over a plain leaf are still direct.
+* True for a bare leaf and for projections over one (spec overrides, axis
+* slicing): those add layers but no new columns. False when the recipe gets at
+* its data through further columns, which happens when discovery reached it via
+* a linker chain.
+*
+* **Why callers care.** A recipe over a single data column is co-indexed by its
+* own axes, so its spec is the whole truth about them. One that needs other
+* columns only lines up after they are joined in, and therefore drags axes into
+* the join that its own spec never mentions — which is why it cannot serve as a
+* primary column, and why `createPlDataTableV3` splits on this.
+*
+* The count comes from {@link ColumnRecipe.getReferencedIds}, which resolves
+* through the whole wrapper chain, so no class walk is involved and foreign
+* `ColumnRecipe` implementations are handled too.
 */
-function isLeafColumn(recipe) {
-	return findDiscovered(recipe) === void 0;
+function hasSingleDataColumn(recipe) {
+	return recipe.getReferencedIds().length === 1;
 }
 /**
-* Data of the bare leaf a "leaf" recipe bottoms out at — reads the leaf-only
-* {@link ColumnLazy.getData} after walking the wrapper chain down via
-* {@link extractLeafColumn}. Returns `undefined` when the recipe is not a leaf (its
-* chain reaches a {@link ColumnDiscoveredRecipe}); the symmetric counterpart
-* of {@link isLeafColumn} returning `false`.
+* @deprecated Renamed to {@link hasSingleDataColumn} — "leaf" read as "you can
+* get data out of it", which is a different question (see
+* {@link hasReachableData}). Same semantics.
 */
-function getLeafColumnData(recipe) {
-	if (!isLeafColumn(recipe)) throw new Error(`getLeafColumnData: recipe ${recipe.id} is not a leaf column`);
-	return extractLeafColumn(recipe)?.getData();
-}
+const isLeafColumn = hasSingleDataColumn;
 /**
-* Walk wrapper layers (Overridden, Filtered) down to the bare {@link ColumnLazy}
-* leaf the chain bottoms out at. Returns `undefined` if the chain reaches a
-* {@link ColumnDiscoveredRecipe} instead — i.e. the recipe is not a leaf
-* ({@link isLeafColumn} would return `false`). Mirror of {@link findDiscovered}.
+* Whether the column's data can be read here and now, consistent with its
+* spec — narrows to {@link DataColumnRecipe}, which exposes `getData()`.
+*
+* True for a bare leaf and for a spec-override over a bare leaf. False for an
+* axis-filtered recipe (its spec has dropped axes the underlying data still
+* carries, so the two no longer line up) and for anything reached through
+* other columns (nothing to read until the engine joins them). In both of
+* those cases the data exists only engine-side: pass `recipe.id` to
+* `createPFrame` / `createPTable` instead of trying to read it.
+*
+* The distinction is settled when the recipe is built, not here — recipes that
+* carry data are instances of a class that declares `getData`. So a `true`
+* result narrows to a value that really has the method, and there is no
+* throwing path behind the guard.
 */
-function extractLeafColumn(recipe) {
-	let current = recipe;
-	while (true) {
-		if (current instanceof ColumnLazyImpl) return current;
-		if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {
-			current = current.getInner();
-			continue;
-		}
-		if (current instanceof ColumnDiscoveredRecipe) throw new Error(`extractLeafColumn: recipe ${recipe.id} is not a leaf column`);
-		throw new Error(`extractLeafColumn: unrecognized recipe layer for ${recipe.id}`);
-	}
+function hasReachableData(recipe) {
+	return recipe instanceof DataColumnImpl || recipe instanceof DataColumnOverriddenRecipe;
 }
 /**
 * Enumerates every column already in `source` and renders distinct labels
@@ -174,6 +180,6 @@ function deriveColumnOptions(source, labelOptions = {}) {
 	}));
 }
 //#endregion
-export { collectLinkerColumns, collectLinkerIds, deriveColumnOptions, getLeafColumnData, hasColumnData, hitQualifications, isLeafColumn, queriesQualifications };
+export { collectLinkerColumns, collectLinkerIds, deriveColumnOptions, hasColumnData, hasReachableData, hasSingleDataColumn, hitQualifications, isLeafColumn, queriesQualifications };
 
 //# sourceMappingURL=utils.js.map

package/dist/columns/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../src/columns/utils.ts"],"sourcesContent":["import {\n  collectSpecQueryColumns,\n  extractPObjectId,\n  isDataInfo,\n  visitDataInfo,\n  type AxisQualification,\n  type ColumnUniversalId,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport { throwError } from \"@milaboratories/helpers\";\nimport type { GlobalCfgRenderCtx } from \"../render/internal\";\nimport { TreeNodeAccessor } from \"../render\";\nimport { deriveDistinctLabels, type DeriveLabelsOptions } from \"../labels/derive_distinct_labels\";\nimport { ColumnLazy, ColumnLazyImpl, type ColumnLazyData } from \"./column_lazy\";\nimport { ColumnDiscoveredRecipe } from \"./column_recipes/column_discovered_recipe\";\nimport { ColumnFilteredRecipe } from \"./column_recipes/column_filtered_recipe\";\nimport { ColumnOverriddenRecipe } from \"./column_recipes/column_overrided_recipe\";\nimport type { ColumnRecipe } from \"./column_recipes/types\";\nimport { ColumnsCollection, isColumnsCollection } from \"./columns_collection\";\nimport type { ColumnsSource } from \"./column_providers/types\";\n\n/**\n * PObjectIds of every non-hit column referenced by `recipe.getQuery()`,\n * deduped in traversal order. The hit column is\n * `extractPObjectId(recipe.id)`; anything else in the query is a linker or\n * other engine-consumed column.\n *\n * Pure query walk — no registry access. Use {@link collectLinkerColumns} for\n * the resolved {@link ColumnLazy} variant.\n */\nexport function collectLinkerIds(recipe: ColumnRecipe): PObjectId[] {\n  const hit = extractPObjectId(recipe.id);\n  const seen = new Set<PObjectId>();\n  const out: PObjectId[] = [];\n  for (const id of collectSpecQueryColumns(recipe.getQuery())) {\n    // Leaf ids in SpecQuery may be rich (e.g. ColumnDiscoveredId) — drop to\n    // bare PObjectId before comparing/registering so we hand the ambient\n    // ColumnRegistry physical ids it can resolve.\n    const bare = extractPObjectId(id);\n    if (bare === hit) continue;\n    if (seen.has(bare)) continue;\n    seen.add(bare);\n    out.push(bare);\n  }\n  return out;\n}\n\n/**\n * {@link collectLinkerIds} resolved against the ambient context as\n * {@link ColumnLazy} instances. Throws if any id fails to resolve —\n * matches the contract of the legacy `resolveLinkers` it replaces.\n */\nexport function collectLinkerColumns(\n  recipe: ColumnRecipe,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): ColumnLazy[] {\n  return collectLinkerIds(recipe).map(\n    (id) =>\n      ColumnLazyImpl.fromId(id, opts) ??\n      throwError(`materializeLinkers: linker ${id} not resolvable`),\n  );\n}\n\n/**\n * Hit-side axis qualifications for the recipe — the ones that should land on\n * the outer-join entry wrapping this column at the consumer boundary.\n *\n * Descends {@link ColumnOverriddenRecipe} / {@link ColumnFilteredRecipe} via\n * `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise\n * returns `[]`. Pure recipe walk — no query-tree introspection.\n */\nexport function hitQualifications(recipe: ColumnRecipe): readonly AxisQualification[] {\n  const discovered = findDiscovered(recipe);\n  return discovered?.getColumnQualifications() ?? [];\n}\n\n/**\n * Per-primary-column axis qualifications for the recipe — applied to the\n * outer primary anchors on this recipe's group side. Keyed by the external\n * primary column id (NOT by columns inside this recipe's own query).\n *\n * Same walk strategy as {@link hitQualifications}.\n */\nexport function queriesQualifications(\n  recipe: ColumnRecipe,\n): Readonly<Record<PObjectId, AxisQualification[]>> {\n  const discovered = findDiscovered(recipe);\n  return discovered?.getQueriesQualifications() ?? {};\n}\n\n/**\n * Whether the recipe's underlying data resources actually carry bytes —\n * strictly stronger than `getDataStatus() === \"present\"`, which only tells\n * that the `.data` field is wired onto the accessor.\n *\n * Walks every physical leaf the recipe depends on via\n * {@link ColumnRecipe.getReferencedIds} (resolves each id back to a\n * {@link ColumnLazy} through the ambient ctx) and ANDs `hasData()` across\n * all of them. Inline {@link PColumnValues} payloads count as present.\n *\n * Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as\n * \"not yet ready\") rather than throwing — this is a UI-facing predicate, not\n * a contract assertion.\n */\nexport function hasColumnData(\n  recipe: ColumnRecipe,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): boolean {\n  for (const id of recipe.getReferencedIds()) {\n    const lazy = ColumnLazyImpl.fromId(id, opts);\n    if (lazy === undefined) return false;\n    if (lazy.getDataStatus() !== \"present\") return false;\n    if (!isLazyDataPresent(lazy.getData())) return false;\n  }\n  return true;\n}\n\nfunction isLazyDataPresent(data: ColumnLazyData): boolean {\n  if (data === undefined) return false;\n  if (Array.isArray(data)) return true;\n  if (data instanceof TreeNodeAccessor) return data.hasData();\n  if (isDataInfo(data)) {\n    let ok = true;\n    visitDataInfo(data, (blob) => {\n      ok &&= blob.hasData();\n    });\n    return ok;\n  }\n  return false;\n}\n\n/**\n * Walk wrapper layers (Overridden, Filtered) until a {@link\n * ColumnDiscoveredRecipe} is found. Returns `undefined` if the recipe chain\n * has no Discovered layer (bare leaves and Overridden-over-leaf cases).\n *\n * Invariant from the wrapper classes themselves: there is at most one\n * Discovered layer in any recipe chain — Discovered is constructed only via\n * its own factory and is never re-wrapped by Discovered.\n */\nfunction findDiscovered(recipe: ColumnRecipe): undefined | ColumnDiscoveredRecipe {\n  let current: ColumnRecipe = recipe;\n  while (true) {\n    if (current instanceof ColumnDiscoveredRecipe) return current;\n    if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {\n      current = current.getInner();\n      continue;\n    }\n    return undefined;\n  }\n}\n\n/**\n * A recipe is a \"leaf\" (directly co-indexed on the anchor, reached without a\n * linker chain) iff its wrapper chain contains no {@link ColumnDiscoveredRecipe}.\n *\n * `Filtered` / `Overridden` over a bare leaf stay leaves; anything wrapping a\n * `Discovered` (e.g. `Overridden(Discovered(...))`) is linked. Use this — not an\n * `instanceof ColumnLazyImpl` check — to split direct vs. linker-joined columns,\n * since projections over a plain leaf are still direct.\n */\nexport function isLeafColumn(recipe: ColumnRecipe): boolean {\n  return findDiscovered(recipe) === undefined;\n}\n\n/**\n * Data of the bare leaf a \"leaf\" recipe bottoms out at — reads the leaf-only\n * {@link ColumnLazy.getData} after walking the wrapper chain down via\n * {@link extractLeafColumn}. Returns `undefined` when the recipe is not a leaf (its\n * chain reaches a {@link ColumnDiscoveredRecipe}); the symmetric counterpart\n * of {@link isLeafColumn} returning `false`.\n */\nexport function getLeafColumnData(recipe: ColumnRecipe): ColumnLazyData {\n  if (!isLeafColumn(recipe)) {\n    throw new Error(`getLeafColumnData: recipe ${recipe.id} is not a leaf column`);\n  }\n  return extractLeafColumn(recipe)?.getData();\n}\n\n/**\n * Walk wrapper layers (Overridden, Filtered) down to the bare {@link ColumnLazy}\n * leaf the chain bottoms out at. Returns `undefined` if the chain reaches a\n * {@link ColumnDiscoveredRecipe} instead — i.e. the recipe is not a leaf\n * ({@link isLeafColumn} would return `false`). Mirror of {@link findDiscovered}.\n */\nfunction extractLeafColumn(recipe: ColumnRecipe): undefined | ColumnLazy {\n  let current: ColumnRecipe = recipe;\n  while (true) {\n    if (current instanceof ColumnLazyImpl) return current;\n    if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {\n      current = current.getInner();\n      continue;\n    }\n    if (current instanceof ColumnDiscoveredRecipe) {\n      throw new Error(`extractLeafColumn: recipe ${recipe.id} is not a leaf column`);\n    }\n    throw new Error(`extractLeafColumn: unrecognized recipe layer for ${recipe.id}`);\n  }\n}\n\n/** Drop-down option built over a {@link ColumnsCollection} — universal-id valued. */\nexport type ColumnOption = {\n  readonly id: ColumnUniversalId;\n  readonly label: string;\n};\n\n/**\n * Enumerates every column already in `source` and renders distinct labels\n * from each recipe's spec. Filtering is the caller's job — pass a\n * {@link ColumnsCollection} that was already narrowed via `.filter(...)` /\n * `.discover(...)`, or hand over a raw {@link ColumnsSource} (provider,\n * accessor, column array, or `\"result_pool\"` / `\"current_block\"` shorthand)\n * to be wrapped on the fly.\n */\nexport function deriveColumnOptions(\n  source: ColumnsCollection | ColumnsSource[],\n  labelOptions: DeriveLabelsOptions = {},\n): ColumnOption[] {\n  const collection = isColumnsCollection(source) ? source : ColumnsCollection(source);\n  const recipes = collection.getColumns();\n  const labels = deriveDistinctLabels(\n    recipes.map((r) => r.getSpec()),\n    labelOptions,\n  );\n  return recipes.map((r, i) => ({ id: r.id, label: labels[i] }));\n}\n"],"mappings":"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"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/columns/utils.ts"],"sourcesContent":["import {\n  collectSpecQueryColumns,\n  extractPObjectId,\n  isDataInfo,\n  visitDataInfo,\n  type AxisQualification,\n  type ColumnUniversalId,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport { throwError } from \"@milaboratories/helpers\";\nimport type { GlobalCfgRenderCtx } from \"../render/internal\";\nimport { TreeNodeAccessor } from \"../render\";\nimport { deriveDistinctLabels, type DeriveLabelsOptions } from \"../labels/derive_distinct_labels\";\nimport { DataColumnRecipe, DataColumnImpl, type ColumnData } from \"./data_column\";\nimport { ColumnDiscoveredRecipe } from \"./column_recipes/column_discovered_recipe\";\nimport { ColumnFilteredRecipe } from \"./column_recipes/column_filtered_recipe\";\nimport {\n  ColumnOverriddenRecipe,\n  DataColumnOverriddenRecipe,\n} from \"./column_recipes/column_overrided_recipe\";\nimport type { ColumnRecipe } from \"./column_recipes/types\";\nimport { ColumnsCollection, isColumnsCollection } from \"./columns_collection\";\nimport type { ColumnsSource } from \"./column_providers/types\";\n\n/**\n * PObjectIds of every non-hit column referenced by `recipe.getQuery()`,\n * deduped in traversal order. The hit column is\n * `extractPObjectId(recipe.id)`; anything else in the query is a linker or\n * other engine-consumed column.\n *\n * Pure query walk — no registry access. Use {@link collectLinkerColumns} for\n * the resolved {@link DataColumnRecipe} variant.\n */\nexport function collectLinkerIds(recipe: ColumnRecipe): PObjectId[] {\n  const hit = extractPObjectId(recipe.id);\n  const seen = new Set<PObjectId>();\n  const out: PObjectId[] = [];\n  for (const id of collectSpecQueryColumns(recipe.getQuery())) {\n    // Leaf ids in SpecQuery may be rich (e.g. ColumnDiscoveredId) — drop to\n    // bare PObjectId before comparing/registering so we hand the ambient\n    // ColumnRegistry physical ids it can resolve.\n    const bare = extractPObjectId(id);\n    if (bare === hit) continue;\n    if (seen.has(bare)) continue;\n    seen.add(bare);\n    out.push(bare);\n  }\n  return out;\n}\n\n/**\n * {@link collectLinkerIds} resolved against the ambient context as\n * {@link DataColumnRecipe} leaves. Throws if any id fails to resolve —\n * matches the contract of the legacy `resolveLinkers` it replaces.\n */\nexport function collectLinkerColumns(\n  recipe: ColumnRecipe,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): DataColumnRecipe<PObjectId>[] {\n  return collectLinkerIds(recipe).map(\n    (id) =>\n      DataColumnImpl.fromId(id, opts) ??\n      throwError(`materializeLinkers: linker ${id} not resolvable`),\n  );\n}\n\n/**\n * Hit-side axis qualifications for the recipe — the ones that should land on\n * the outer-join entry wrapping this column at the consumer boundary.\n *\n * Descends {@link ColumnOverriddenRecipe} / {@link ColumnFilteredRecipe} via\n * `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise\n * returns `[]`. Pure recipe walk — no query-tree introspection.\n */\nexport function hitQualifications(recipe: ColumnRecipe): readonly AxisQualification[] {\n  const discovered = findDiscovered(recipe);\n  return discovered?.getColumnQualifications() ?? [];\n}\n\n/**\n * Per-primary-column axis qualifications for the recipe — applied to the\n * outer primary anchors on this recipe's group side. Keyed by the external\n * primary column id (NOT by columns inside this recipe's own query).\n *\n * Same walk strategy as {@link hitQualifications}.\n */\nexport function queriesQualifications(\n  recipe: ColumnRecipe,\n): Readonly<Record<PObjectId, AxisQualification[]>> {\n  const discovered = findDiscovered(recipe);\n  return discovered?.getQueriesQualifications() ?? {};\n}\n\n/**\n * Whether the recipe's underlying data resources actually carry bytes —\n * strictly stronger than `getDataStatus() === \"present\"`, which only tells\n * that the `.data` field is wired onto the accessor.\n *\n * Walks every physical leaf the recipe depends on via\n * {@link ColumnRecipe.getReferencedIds} (resolves each id back to a\n * {@link DataColumnRecipe} through the ambient ctx) and ANDs `hasData()` across\n * all of them. Inline {@link PColumnValues} payloads count as present.\n *\n * Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as\n * \"not yet ready\") rather than throwing — this is a UI-facing predicate, not\n * a contract assertion.\n */\nexport function hasColumnData(\n  recipe: ColumnRecipe,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): boolean {\n  for (const id of recipe.getReferencedIds()) {\n    const leaf = DataColumnImpl.fromId(id, opts);\n    if (leaf === undefined) return false;\n    if (leaf.getDataStatus() !== \"present\") return false;\n    if (!isLeafDataPresent(leaf.getData())) return false;\n  }\n  return true;\n}\n\nfunction isLeafDataPresent(data: ColumnData): boolean {\n  if (data === undefined) return false;\n  if (Array.isArray(data)) return true;\n  if (data instanceof TreeNodeAccessor) return data.hasData();\n  if (isDataInfo(data)) {\n    let ok = true;\n    visitDataInfo(data, (blob) => {\n      ok &&= blob.hasData();\n    });\n    return ok;\n  }\n  return false;\n}\n\n/**\n * Walk wrapper layers (Overridden, Filtered) until a {@link\n * ColumnDiscoveredRecipe} is found. Returns `undefined` if the recipe chain\n * has no Discovered layer (bare leaves and Overridden-over-leaf cases).\n *\n * Invariant from the wrapper classes themselves: there is at most one\n * Discovered layer in any recipe chain — Discovered is constructed only via\n * its own factory and is never re-wrapped by Discovered.\n */\nfunction findDiscovered(recipe: ColumnRecipe): undefined | ColumnDiscoveredRecipe {\n  let current: ColumnRecipe = recipe;\n  while (true) {\n    if (current instanceof ColumnDiscoveredRecipe) return current;\n    if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {\n      current = current.getInner();\n      continue;\n    }\n    return undefined;\n  }\n}\n\n/**\n * Whether the recipe reads exactly one data column — its own — rather than\n * reaching through others.\n *\n * True for a bare leaf and for projections over one (spec overrides, axis\n * slicing): those add layers but no new columns. False when the recipe gets at\n * its data through further columns, which happens when discovery reached it via\n * a linker chain.\n *\n * **Why callers care.** A recipe over a single data column is co-indexed by its\n * own axes, so its spec is the whole truth about them. One that needs other\n * columns only lines up after they are joined in, and therefore drags axes into\n * the join that its own spec never mentions — which is why it cannot serve as a\n * primary column, and why `createPlDataTableV3` splits on this.\n *\n * The count comes from {@link ColumnRecipe.getReferencedIds}, which resolves\n * through the whole wrapper chain, so no class walk is involved and foreign\n * `ColumnRecipe` implementations are handled too.\n */\nexport function hasSingleDataColumn(recipe: ColumnRecipe): boolean {\n  return recipe.getReferencedIds().length === 1;\n}\n\n/**\n * @deprecated Renamed to {@link hasSingleDataColumn} — \"leaf\" read as \"you can\n * get data out of it\", which is a different question (see\n * {@link hasReachableData}). Same semantics.\n */\nexport const isLeafColumn = hasSingleDataColumn;\n\n/**\n * Whether the column's data can be read here and now, consistent with its\n * spec — narrows to {@link DataColumnRecipe}, which exposes `getData()`.\n *\n * True for a bare leaf and for a spec-override over a bare leaf. False for an\n * axis-filtered recipe (its spec has dropped axes the underlying data still\n * carries, so the two no longer line up) and for anything reached through\n * other columns (nothing to read until the engine joins them). In both of\n * those cases the data exists only engine-side: pass `recipe.id` to\n * `createPFrame` / `createPTable` instead of trying to read it.\n *\n * The distinction is settled when the recipe is built, not here — recipes that\n * carry data are instances of a class that declares `getData`. So a `true`\n * result narrows to a value that really has the method, and there is no\n * throwing path behind the guard.\n */\nexport function hasReachableData(recipe: ColumnRecipe): recipe is DataColumnRecipe {\n  return recipe instanceof DataColumnImpl || recipe instanceof DataColumnOverriddenRecipe;\n}\n\n/** Drop-down option built over a {@link ColumnsCollection} — universal-id valued. */\nexport type ColumnOption = {\n  readonly id: ColumnUniversalId;\n  readonly label: string;\n};\n\n/**\n * Enumerates every column already in `source` and renders distinct labels\n * from each recipe's spec. Filtering is the caller's job — pass a\n * {@link ColumnsCollection} that was already narrowed via `.filter(...)` /\n * `.discover(...)`, or hand over a raw {@link ColumnsSource} (provider,\n * accessor, column array, or `\"result_pool\"` / `\"current_block\"` shorthand)\n * to be wrapped on the fly.\n */\nexport function deriveColumnOptions(\n  source: ColumnsCollection | ColumnsSource[],\n  labelOptions: DeriveLabelsOptions = {},\n): ColumnOption[] {\n  const collection = isColumnsCollection(source) ? source : ColumnsCollection(source);\n  const recipes = collection.getColumns();\n  const labels = deriveDistinctLabels(\n    recipes.map((r) => r.getSpec()),\n    labelOptions,\n  );\n  return recipes.map((r, i) => ({ id: r.id, label: labels[i] }));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,iBAAiB,QAAmC;CAClE,MAAM,MAAM,iBAAiB,OAAO,EAAE;CACtC,MAAM,uBAAO,IAAI,IAAe;CAChC,MAAM,MAAmB,CAAC;CAC1B,KAAK,MAAM,MAAM,wBAAwB,OAAO,SAAS,CAAC,GAAG;EAI3D,MAAM,OAAO,iBAAiB,EAAE;EAChC,IAAI,SAAS,KAAK;EAClB,IAAI,KAAK,IAAI,IAAI,GAAG;EACpB,KAAK,IAAI,IAAI;EACb,IAAI,KAAK,IAAI;CACf;CACA,OAAO;AACT;;;;;;AAOA,SAAgB,qBACd,QACA,OAAqC,CAAC,GACP;CAC/B,OAAO,iBAAiB,MAAM,CAAC,CAAC,KAC7B,OACC,eAAe,OAAO,IAAI,IAAI,KAC9B,WAAW,8BAA8B,GAAG,gBAAgB,CAChE;AACF;;;;;;;;;AAUA,SAAgB,kBAAkB,QAAoD;CAEpF,OADmB,eAAe,MAClB,CAAC,EAAE,wBAAwB,KAAK,CAAC;AACnD;;;;;;;;AASA,SAAgB,sBACd,QACkD;CAElD,OADmB,eAAe,MAClB,CAAC,EAAE,yBAAyB,KAAK,CAAC;AACpD;;;;;;;;;;;;;;;AAgBA,SAAgB,cACd,QACA,OAAqC,CAAC,GAC7B;CACT,KAAK,MAAM,MAAM,OAAO,iBAAiB,GAAG;EAC1C,MAAM,OAAO,eAAe,OAAO,IAAI,IAAI;EAC3C,IAAI,SAAS,KAAA,GAAW,OAAO;EAC/B,IAAI,KAAK,cAAc,MAAM,WAAW,OAAO;EAC/C,IAAI,CAAC,kBAAkB,KAAK,QAAQ,CAAC,GAAG,OAAO;CACjD;CACA,OAAO;AACT;AAEA,SAAS,kBAAkB,MAA2B;CACpD,IAAI,SAAS,KAAA,GAAW,OAAO;CAC/B,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO;CAChC,IAAI,gBAAgB,kBAAkB,OAAO,KAAK,QAAQ;CAC1D,IAAI,WAAW,IAAI,GAAG;EACpB,IAAI,KAAK;EACT,cAAc,OAAO,SAAS;GAC5B,OAAO,KAAK,QAAQ;EACtB,CAAC;EACD,OAAO;CACT;CACA,OAAO;AACT;;;;;;;;;;AAWA,SAAS,eAAe,QAA0D;CAChF,IAAI,UAAwB;CAC5B,OAAO,MAAM;EACX,IAAI,mBAAmB,wBAAwB,OAAO;EACtD,IAAI,mBAAmB,0BAA0B,mBAAmB,sBAAsB;GACxF,UAAU,QAAQ,SAAS;GAC3B;EACF;EACA;CACF;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,oBAAoB,QAA+B;CACjE,OAAO,OAAO,iBAAiB,CAAC,CAAC,WAAW;AAC9C;;;;;;AAOA,MAAa,eAAe;;;;;;;;;;;;;;;;;AAkB5B,SAAgB,iBAAiB,QAAkD;CACjF,OAAO,kBAAkB,kBAAkB,kBAAkB;AAC/D;;;;;;;;;AAgBA,SAAgB,oBACd,QACA,eAAoC,CAAC,GACrB;CAEhB,MAAM,WADa,oBAAoB,MAAM,IAAI,SAAS,kBAAkB,MAAM,EAAA,CACvD,WAAW;CACtC,MAAM,SAAS,qBACb,QAAQ,KAAK,MAAM,EAAE,QAAQ,CAAC,GAC9B,YACF;CACA,OAAO,QAAQ,KAAK,GAAG,OAAO;EAAE,IAAI,EAAE;EAAI,OAAO,OAAO;CAAG,EAAE;AAC/D"}

package/dist/components/PlDataTable/createPlDataTable/createPTableDefV2.cjs

@@ -1,4 +1,4 @@
-const require_column_lazy = require("../../../columns/column_lazy.cjs");
+const require_data_column = require("../../../columns/data_column.cjs");
 require("../../../columns/index.cjs");
 const require_createPTableDefV3 = require("./createPTableDefV3.cjs");
 let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
@@ -14,8 +14,8 @@ function createPTableDefV2(params) {
 	}
 	secondaryColumns.push(...params.labelColumns);
 	return require_createPTableDefV3.createPTableDefV3({
-		primary: coreColumns.map((column) => require_column_lazy.ColumnLazyImpl.fromColumn(column)),
-		secondary: secondaryColumns.map((column) => require_column_lazy.ColumnLazyImpl.fromColumn(column)),
+		primary: coreColumns.map((column) => require_data_column.DataColumn.fromColumn(column)),
+		secondary: secondaryColumns.map((column) => require_data_column.DataColumn.fromColumn(column)),
 		primaryJoinType: params.coreJoinType,
 		filters: params.filters,
 		sorting: params.sorting

package/dist/components/PlDataTable/createPlDataTable/createPTableDefV2.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createPTableDefV2.cjs","names":["createPTableDefV3","ColumnLazyImpl"],"sources":["../../../../src/components/PlDataTable/createPlDataTable/createPTableDefV2.ts"],"sourcesContent":["import type {\n  ColumnUniversalId,\n  PColumn,\n  PColumnIdAndSpec,\n  PTableSorting,\n  PTableDefV2,\n} from \"@milaboratories/pl-model-common\";\nimport { getColumnIdAndSpec } from \"@milaboratories/pl-model-common\";\nimport type { PColumnDataUniversal } from \"../../../render\";\nimport { isFunction } from \"es-toolkit\";\nimport type { PlDataTableFilters } from \"../typesV8\";\nimport { createPTableDefV3 } from \"./createPTableDefV3\";\nimport { ColumnLazyImpl } from \"../../../columns\";\n\nexport function createPTableDefV2(params: {\n  columns: PColumn<undefined | PColumnDataUniversal>[];\n  labelColumns: PColumn<undefined | PColumnDataUniversal>[];\n  coreJoinType: \"inner\" | \"full\";\n  filters: null | PlDataTableFilters;\n  sorting: PTableSorting[];\n  coreColumnPredicate?: (spec: PColumnIdAndSpec) => boolean;\n}): PTableDefV2<ColumnUniversalId> {\n  let coreColumns = params.columns;\n  const secondaryColumns: typeof params.columns = [];\n\n  if (isFunction(params.coreColumnPredicate)) {\n    coreColumns = [];\n    for (const c of params.columns)\n      if (params.coreColumnPredicate(getColumnIdAndSpec(c))) coreColumns.push(c);\n      else secondaryColumns.push(c);\n  }\n\n  secondaryColumns.push(...params.labelColumns);\n\n  return createPTableDefV3({\n    primary: coreColumns.map((column) => ColumnLazyImpl.fromColumn(column)),\n    secondary: secondaryColumns.map((column) => ColumnLazyImpl.fromColumn(column)),\n    primaryJoinType: params.coreJoinType,\n    filters: params.filters,\n    sorting: params.sorting,\n  });\n}\n"],"mappings":";;;;;;AAcA,SAAgB,kBAAkB,QAOC;CACjC,IAAI,cAAc,OAAO;CACzB,MAAM,mBAA0C,CAAC;CAEjD,KAAA,GAAA,WAAA,WAAA,CAAe,OAAO,mBAAmB,GAAG;EAC1C,cAAc,CAAC;EACf,KAAK,MAAM,KAAK,OAAO,SACrB,IAAI,OAAO,qBAAA,GAAA,gCAAA,mBAAA,CAAuC,CAAC,CAAC,GAAG,YAAY,KAAK,CAAC;OACpE,iBAAiB,KAAK,CAAC;CAChC;CAEA,iBAAiB,KAAK,GAAG,OAAO,YAAY;CAE5C,OAAOA,0BAAAA,kBAAkB;EACvB,SAAS,YAAY,KAAK,WAAWC,oBAAAA,eAAe,WAAW,MAAM,CAAC;EACtE,WAAW,iBAAiB,KAAK,WAAWA,oBAAAA,eAAe,WAAW,MAAM,CAAC;EAC7E,iBAAiB,OAAO;EACxB,SAAS,OAAO;EAChB,SAAS,OAAO;CAClB,CAAC;AACH"}
+{"version":3,"file":"createPTableDefV2.cjs","names":["createPTableDefV3","DataColumn"],"sources":["../../../../src/components/PlDataTable/createPlDataTable/createPTableDefV2.ts"],"sourcesContent":["import type {\n  ColumnUniversalId,\n  PColumn,\n  PColumnIdAndSpec,\n  PTableSorting,\n  PTableDefV2,\n} from \"@milaboratories/pl-model-common\";\nimport { getColumnIdAndSpec } from \"@milaboratories/pl-model-common\";\nimport type { PColumnDataUniversal } from \"../../../render\";\nimport { isFunction } from \"es-toolkit\";\nimport type { PlDataTableFilters } from \"../typesV8\";\nimport { createPTableDefV3 } from \"./createPTableDefV3\";\nimport { DataColumn } from \"../../../columns\";\n\nexport function createPTableDefV2(params: {\n  columns: PColumn<undefined | PColumnDataUniversal>[];\n  labelColumns: PColumn<undefined | PColumnDataUniversal>[];\n  coreJoinType: \"inner\" | \"full\";\n  filters: null | PlDataTableFilters;\n  sorting: PTableSorting[];\n  coreColumnPredicate?: (spec: PColumnIdAndSpec) => boolean;\n}): PTableDefV2<ColumnUniversalId> {\n  let coreColumns = params.columns;\n  const secondaryColumns: typeof params.columns = [];\n\n  if (isFunction(params.coreColumnPredicate)) {\n    coreColumns = [];\n    for (const c of params.columns)\n      if (params.coreColumnPredicate(getColumnIdAndSpec(c))) coreColumns.push(c);\n      else secondaryColumns.push(c);\n  }\n\n  secondaryColumns.push(...params.labelColumns);\n\n  return createPTableDefV3({\n    primary: coreColumns.map((column) => DataColumn.fromColumn(column)),\n    secondary: secondaryColumns.map((column) => DataColumn.fromColumn(column)),\n    primaryJoinType: params.coreJoinType,\n    filters: params.filters,\n    sorting: params.sorting,\n  });\n}\n"],"mappings":";;;;;;AAcA,SAAgB,kBAAkB,QAOC;CACjC,IAAI,cAAc,OAAO;CACzB,MAAM,mBAA0C,CAAC;CAEjD,KAAA,GAAA,WAAA,WAAA,CAAe,OAAO,mBAAmB,GAAG;EAC1C,cAAc,CAAC;EACf,KAAK,MAAM,KAAK,OAAO,SACrB,IAAI,OAAO,qBAAA,GAAA,gCAAA,mBAAA,CAAuC,CAAC,CAAC,GAAG,YAAY,KAAK,CAAC;OACpE,iBAAiB,KAAK,CAAC;CAChC;CAEA,iBAAiB,KAAK,GAAG,OAAO,YAAY;CAE5C,OAAOA,0BAAAA,kBAAkB;EACvB,SAAS,YAAY,KAAK,WAAWC,oBAAAA,WAAW,WAAW,MAAM,CAAC;EAClE,WAAW,iBAAiB,KAAK,WAAWA,oBAAAA,WAAW,WAAW,MAAM,CAAC;EACzE,iBAAiB,OAAO;EACxB,SAAS,OAAO;EAChB,SAAS,OAAO;CAClB,CAAC;AACH"}

package/dist/components/PlDataTable/createPlDataTable/createPTableDefV2.js

@@ -1,4 +1,4 @@
-import { ColumnLazyImpl } from "../../../columns/column_lazy.js";
+import { DataColumn } from "../../../columns/data_column.js";
 import "../../../columns/index.js";
 import { createPTableDefV3 } from "./createPTableDefV3.js";
 import { getColumnIdAndSpec } from "@milaboratories/pl-model-common";
@@ -14,8 +14,8 @@ function createPTableDefV2(params) {
 	}
 	secondaryColumns.push(...params.labelColumns);
 	return createPTableDefV3({
-		primary: coreColumns.map((column) => ColumnLazyImpl.fromColumn(column)),
-		secondary: secondaryColumns.map((column) => ColumnLazyImpl.fromColumn(column)),
+		primary: coreColumns.map((column) => DataColumn.fromColumn(column)),
+		secondary: secondaryColumns.map((column) => DataColumn.fromColumn(column)),
 		primaryJoinType: params.coreJoinType,
 		filters: params.filters,
 		sorting: params.sorting

package/dist/components/PlDataTable/createPlDataTable/createPTableDefV2.js.map

@@ -1 +1 @@
-{"version":3,"file":"createPTableDefV2.js","names":[],"sources":["../../../../src/components/PlDataTable/createPlDataTable/createPTableDefV2.ts"],"sourcesContent":["import type {\n  ColumnUniversalId,\n  PColumn,\n  PColumnIdAndSpec,\n  PTableSorting,\n  PTableDefV2,\n} from \"@milaboratories/pl-model-common\";\nimport { getColumnIdAndSpec } from \"@milaboratories/pl-model-common\";\nimport type { PColumnDataUniversal } from \"../../../render\";\nimport { isFunction } from \"es-toolkit\";\nimport type { PlDataTableFilters } from \"../typesV8\";\nimport { createPTableDefV3 } from \"./createPTableDefV3\";\nimport { ColumnLazyImpl } from \"../../../columns\";\n\nexport function createPTableDefV2(params: {\n  columns: PColumn<undefined | PColumnDataUniversal>[];\n  labelColumns: PColumn<undefined | PColumnDataUniversal>[];\n  coreJoinType: \"inner\" | \"full\";\n  filters: null | PlDataTableFilters;\n  sorting: PTableSorting[];\n  coreColumnPredicate?: (spec: PColumnIdAndSpec) => boolean;\n}): PTableDefV2<ColumnUniversalId> {\n  let coreColumns = params.columns;\n  const secondaryColumns: typeof params.columns = [];\n\n  if (isFunction(params.coreColumnPredicate)) {\n    coreColumns = [];\n    for (const c of params.columns)\n      if (params.coreColumnPredicate(getColumnIdAndSpec(c))) coreColumns.push(c);\n      else secondaryColumns.push(c);\n  }\n\n  secondaryColumns.push(...params.labelColumns);\n\n  return createPTableDefV3({\n    primary: coreColumns.map((column) => ColumnLazyImpl.fromColumn(column)),\n    secondary: secondaryColumns.map((column) => ColumnLazyImpl.fromColumn(column)),\n    primaryJoinType: params.coreJoinType,\n    filters: params.filters,\n    sorting: params.sorting,\n  });\n}\n"],"mappings":";;;;;;AAcA,SAAgB,kBAAkB,QAOC;CACjC,IAAI,cAAc,OAAO;CACzB,MAAM,mBAA0C,CAAC;CAEjD,IAAI,WAAW,OAAO,mBAAmB,GAAG;EAC1C,cAAc,CAAC;EACf,KAAK,MAAM,KAAK,OAAO,SACrB,IAAI,OAAO,oBAAoB,mBAAmB,CAAC,CAAC,GAAG,YAAY,KAAK,CAAC;OACpE,iBAAiB,KAAK,CAAC;CAChC;CAEA,iBAAiB,KAAK,GAAG,OAAO,YAAY;CAE5C,OAAO,kBAAkB;EACvB,SAAS,YAAY,KAAK,WAAW,eAAe,WAAW,MAAM,CAAC;EACtE,WAAW,iBAAiB,KAAK,WAAW,eAAe,WAAW,MAAM,CAAC;EAC7E,iBAAiB,OAAO;EACxB,SAAS,OAAO;EAChB,SAAS,OAAO;CAClB,CAAC;AACH"}
+{"version":3,"file":"createPTableDefV2.js","names":[],"sources":["../../../../src/components/PlDataTable/createPlDataTable/createPTableDefV2.ts"],"sourcesContent":["import type {\n  ColumnUniversalId,\n  PColumn,\n  PColumnIdAndSpec,\n  PTableSorting,\n  PTableDefV2,\n} from \"@milaboratories/pl-model-common\";\nimport { getColumnIdAndSpec } from \"@milaboratories/pl-model-common\";\nimport type { PColumnDataUniversal } from \"../../../render\";\nimport { isFunction } from \"es-toolkit\";\nimport type { PlDataTableFilters } from \"../typesV8\";\nimport { createPTableDefV3 } from \"./createPTableDefV3\";\nimport { DataColumn } from \"../../../columns\";\n\nexport function createPTableDefV2(params: {\n  columns: PColumn<undefined | PColumnDataUniversal>[];\n  labelColumns: PColumn<undefined | PColumnDataUniversal>[];\n  coreJoinType: \"inner\" | \"full\";\n  filters: null | PlDataTableFilters;\n  sorting: PTableSorting[];\n  coreColumnPredicate?: (spec: PColumnIdAndSpec) => boolean;\n}): PTableDefV2<ColumnUniversalId> {\n  let coreColumns = params.columns;\n  const secondaryColumns: typeof params.columns = [];\n\n  if (isFunction(params.coreColumnPredicate)) {\n    coreColumns = [];\n    for (const c of params.columns)\n      if (params.coreColumnPredicate(getColumnIdAndSpec(c))) coreColumns.push(c);\n      else secondaryColumns.push(c);\n  }\n\n  secondaryColumns.push(...params.labelColumns);\n\n  return createPTableDefV3({\n    primary: coreColumns.map((column) => DataColumn.fromColumn(column)),\n    secondary: secondaryColumns.map((column) => DataColumn.fromColumn(column)),\n    primaryJoinType: params.coreJoinType,\n    filters: params.filters,\n    sorting: params.sorting,\n  });\n}\n"],"mappings":";;;;;;AAcA,SAAgB,kBAAkB,QAOC;CACjC,IAAI,cAAc,OAAO;CACzB,MAAM,mBAA0C,CAAC;CAEjD,IAAI,WAAW,OAAO,mBAAmB,GAAG;EAC1C,cAAc,CAAC;EACf,KAAK,MAAM,KAAK,OAAO,SACrB,IAAI,OAAO,oBAAoB,mBAAmB,CAAC,CAAC,GAAG,YAAY,KAAK,CAAC;OACpE,iBAAiB,KAAK,CAAC;CAChC;CAEA,iBAAiB,KAAK,GAAG,OAAO,YAAY;CAE5C,OAAO,kBAAkB;EACvB,SAAS,YAAY,KAAK,WAAW,WAAW,WAAW,MAAM,CAAC;EAClE,WAAW,iBAAiB,KAAK,WAAW,WAAW,WAAW,MAAM,CAAC;EACzE,iBAAiB,OAAO;EACxB,SAAS,OAAO;EAChB,SAAS,OAAO;CAClB,CAAC;AACH"}

package/dist/components/PlDataTable/createPlDataTable/createPlDataTableV2.cjs

@@ -2,7 +2,7 @@ const require_label = require("../../../render/util/label.cjs");
 const require_pcolumn_data = require("../../../render/util/pcolumn_data.cjs");
 const require_column_collection = require("../../../render/util/column_collection.cjs");
 require("../../../render/index.cjs");
-const require_column_lazy = require("../../../columns/column_lazy.cjs");
+const require_data_column = require("../../../columns/data_column.cjs");
 require("../../../columns/index.cjs");
 const require_traverse = require("../../../filters/traverse.cjs");
 const require_state_migration = require("../state-migration.cjs");
@@ -41,7 +41,7 @@ function createPlDataTableV2(ctx, columns, tableState, options) {
 		};
 	});
 	const fullColumns = [...columns, ...fullLabelColumns];
-	const resolver = require_columnResolver.createColumnResolver(fullColumns.map((c) => require_column_lazy.ColumnLazyImpl.fromColumn(c)), { warn: ctx.logWarn.bind(ctx) });
+	const resolver = require_columnResolver.createColumnResolver(fullColumns.map((c) => require_data_column.DataColumn.fromColumn(c)), { warn: ctx.logWarn.bind(ctx) });
 	const rawFilters = tableStateNormalized.pTableParams.filters;
 	const rawDefaultFilters = options?.filters ?? void 0;
 	const filters = remapFiltersThrowing(rawFilters, resolver, "filter");

package/dist/components/PlDataTable/createPlDataTable/createPlDataTableV2.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createPlDataTableV2.cjs","names":["upgradePlDataTableStateV2","getMatchingLabelColumns","deriveLabels","identity","Annotation","createColumnResolver","ColumnLazyImpl","createPTableDefV2","isColumnOptional","getColumnIdAndSpec","allPColumnsReady","traverseFilterSpec","PColumnCollection","PColumnName"],"sources":["../../../../src/components/PlDataTable/createPlDataTable/createPlDataTableV2.ts"],"sourcesContent":["import type {\n  ColumnUniversalId,\n  FilterSpecNode,\n  PColumn,\n  PTableColumnIdColumn,\n  PTableSorting,\n} from \"@milaboratories/pl-model-common\";\nimport {\n  Annotation,\n  getColumnIdAndSpec,\n  isLinkerColumn,\n  PColumnName,\n} from \"@milaboratories/pl-model-common\";\nimport type {\n  AxisLabelProvider,\n  ColumnProvider,\n  PColumnDataUniversal,\n  RenderCtxBase,\n} from \"../../../render\";\nimport { allPColumnsReady, deriveLabels, PColumnCollection } from \"../../../render\";\nimport { identity } from \"es-toolkit\";\nimport type {\n  CreatePlDataTableOps,\n  PlDataTableFilters,\n  PlDataTableFilterSpecLeaf,\n  PlDataTableModel,\n} from \"../typesV8\";\nimport { upgradePlDataTableStateV2 } from \"../state-migration\";\nimport type { PlDataTableStateV2 } from \"../state-migration\";\nimport { getMatchingLabelColumns } from \"../labels\";\nimport { collectFilterSpecColumns, traverseFilterSpec } from \"../../../filters/traverse\";\nimport { createPTableDefV2 } from \"./createPTableDefV2\";\nimport { isColumnOptional } from \"./utils\";\nimport { ColumnLazyImpl } from \"../../../columns\";\nimport { createColumnResolver, type ColumnResolver } from \"../columnResolver\";\nimport { isNil, type Nil } from \"@milaboratories/helpers\";\n\n/**\n * @deprecated This function is deprecated and will be removed in future. Please migrate to createPlDataTable with v3 options for improved column discovery and display configuration. See createPlDataTableOptionsV3 for details on the new options format and migration guidance.\n */\nexport type createPlDataTableOptionsV2 = {\n  columns: PColumn<PColumnDataUniversal>[];\n  tableState?: PlDataTableStateV2;\n  options?: CreatePlDataTableOps;\n};\n\n/**\n * Create p-table spec and handle given ui table state\n *\n * @deprecated This version of createPlDataTable is deprecated and will be removed in future. Please migrate to v3 by switching to the new options format and providing necessary information for column discovery and display configuration. See createPlDataTableOptionsV3 for details.\n * @param ctx context\n * @param columns column list\n * @param tableState table ui state\n * @returns PlAgDataTableV2 table source\n */\nexport function createPlDataTableV2<A, U>(\n  ctx: RenderCtxBase<A, U>,\n  columns: createPlDataTableOptionsV2[\"columns\"],\n  tableState?: createPlDataTableOptionsV2[\"tableState\"],\n  options?: createPlDataTableOptionsV2[\"options\"],\n): PlDataTableModel | undefined {\n  if (columns.length === 0) return undefined;\n\n  const tableStateNormalized = upgradePlDataTableStateV2(tableState);\n  const allLabelColumns = getAllLabelColumns(ctx.resultPool) ?? [];\n\n  let fullLabelColumns = getMatchingLabelColumns(columns, allLabelColumns);\n  fullLabelColumns = deriveLabels(fullLabelColumns, identity, { includeNativeLabel: true }).map(\n    (v) => {\n      return {\n        ...v.value,\n        spec: {\n          ...v.value.spec,\n          annotations: {\n            ...v.value.spec.annotations,\n            [Annotation.Label]: v.label,\n          },\n        },\n      };\n    },\n  );\n\n  const fullColumns = [...columns, ...fullLabelColumns];\n\n  const resolver = createColumnResolver(\n    fullColumns.map((c) => ColumnLazyImpl.fromColumn(c)),\n    { warn: ctx.logWarn.bind(ctx) },\n  );\n\n  // -- Filtering: rewrite via resolver, throw if any reference is unresolved --\n  const rawFilters = tableStateNormalized.pTableParams.filters;\n  const rawDefaultFilters = options?.filters ?? undefined;\n  const filters = remapFiltersThrowing(rawFilters, resolver, \"filter\");\n  const defaultFilters = remapFiltersThrowing(\n    rawDefaultFilters ?? null,\n    resolver,\n    \"default filter\",\n  );\n\n  // -- Sorting: rewrite via resolver, throw if any reference is unresolved --\n  const userSorting = tableStateNormalized.pTableParams.sorting;\n  const rawSorting = (isNil(userSorting) ? options?.sorting : userSorting) ?? [];\n  const sorting = remapSortingThrowing(rawSorting, resolver);\n\n  const coreJoinType = options?.coreJoinType ?? \"full\";\n  const fullDef = createPTableDefV2({\n    columns,\n    labelColumns: fullLabelColumns,\n    coreJoinType,\n    filters: filters ?? null,\n    sorting,\n    coreColumnPredicate: options?.coreColumnPredicate,\n  });\n\n  const fullHandle = ctx.createPTableV2(fullDef);\n  const pframeHandle = ctx.createPFrame(fullColumns);\n  if (!fullHandle || !pframeHandle) return undefined;\n\n  const hiddenColumns = new Set<ColumnUniversalId>(\n    ((): ColumnUniversalId[] => {\n      // Inner join works as a filter - all columns must be present\n      if (coreJoinType === \"inner\") return [];\n\n      const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;\n      if (hiddenColIds !== null) {\n        return hiddenColIds\n          .filter((s): s is PTableColumnIdColumn => s.type === \"column\")\n          .map((s) => s.id);\n      }\n\n      return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);\n    })(),\n  );\n\n  // Preserve linker columns\n  columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));\n\n  // Preserve core columns as they change the shape of join.\n  const coreColumnPredicate = options?.coreColumnPredicate;\n  if (coreColumnPredicate) {\n    const coreColumns = columns.flatMap((c) =>\n      coreColumnPredicate(getColumnIdAndSpec(c)) ? [c.id] : [],\n    );\n    coreColumns.forEach((c) => hiddenColumns.delete(c));\n  }\n\n  // Preserve sorted columns from being hidden\n  sorting\n    .map((s) => s.column)\n    .filter((c): c is PTableColumnIdColumn => c.type === \"column\")\n    .forEach((c) => hiddenColumns.delete(c.id));\n\n  // Preserve filter columns from being hidden\n  if (filters) {\n    collectFilterSpecColumns(filters)\n      .flatMap((c) => (c.type === \"column\" ? [c.id] : []))\n      .forEach((c) => hiddenColumns.delete(c));\n  }\n\n  const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));\n  const visibleLabelColumns = getMatchingLabelColumns(\n    visibleColumns.map(getColumnIdAndSpec),\n    allLabelColumns,\n  );\n\n  // if at least one column is not yet computed, we can't show the table\n  if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns])) return undefined;\n\n  const visibleDef = createPTableDefV2({\n    columns: visibleColumns,\n    labelColumns: visibleLabelColumns,\n    coreJoinType,\n    filters: filters ?? null,\n    sorting,\n    coreColumnPredicate,\n  });\n  const visibleHandle = ctx.createPTableV2(visibleDef);\n\n  if (!visibleHandle) return undefined;\n\n  return {\n    sourceId: tableStateNormalized.pTableParams.sourceId,\n    fullTableHandle: fullHandle,\n    fullPframeHandle: pframeHandle,\n    visibleTableHandle: visibleHandle,\n    defaultFilters: defaultFilters ?? undefined,\n  } satisfies PlDataTableModel;\n}\n\n/** Rewrite filter column refs through the resolver; throw on any unresolved ref. */\nfunction remapFiltersThrowing(\n  filters: Nil | PlDataTableFilters,\n  resolver: ColumnResolver,\n  label: string,\n): Nil | PlDataTableFilters {\n  if (isNil(filters)) return filters;\n\n  type Node = FilterSpecNode<PlDataTableFilterSpecLeaf>;\n  return traverseFilterSpec(filters, {\n    leaf: (leaf): Node => {\n      if (leaf.type === undefined) return leaf;\n      const result = { ...leaf };\n      if (\"column\" in result) {\n        const c = resolver(result.column);\n        if (isNil(c))\n          throw new Error(\n            `Invalid ${label} column ${JSON.stringify(result.column)}: column reference does not match the table columns`,\n          );\n        result.column = c;\n      }\n      if (\"rhs\" in result) {\n        const c = resolver(result.rhs);\n        if (isNil(c))\n          throw new Error(\n            `Invalid ${label} column ${JSON.stringify(result.rhs)}: column reference does not match the table columns`,\n          );\n        result.rhs = c;\n      }\n      return result;\n    },\n    and: (results): Node => ({ type: \"and\", filters: results }),\n    or: (results): Node => ({ type: \"or\", filters: results }),\n    not: (result): Node => ({ type: \"not\", filter: result }),\n  }) as PlDataTableFilters;\n}\n\n/** Rewrite sorting column refs through the resolver; throw on any unresolved ref. */\nfunction remapSortingThrowing(sorting: PTableSorting[], resolver: ColumnResolver): PTableSorting[] {\n  return sorting.map((s) => {\n    const c = resolver(s.column);\n    if (isNil(c))\n      throw new Error(\n        `Invalid sorting column ${JSON.stringify(s.column)}: column reference does not match the table columns`,\n      );\n    return { ...s, column: c };\n  });\n}\n\nfunction getAllLabelColumns(\n  resultPool: AxisLabelProvider & ColumnProvider,\n): undefined | PColumn<undefined | PColumnDataUniversal>[] {\n  return new PColumnCollection()\n    .addAxisLabelProvider(resultPool)\n    .addColumnProvider(resultPool)\n    .getColumns(\n      {\n        name: PColumnName.Label,\n        axes: [{}], // exactly one axis\n      },\n      { dontWaitAllData: true, overrideLabelAnnotation: false },\n    );\n}\n"],"mappings":"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"}
+{"version":3,"file":"createPlDataTableV2.cjs","names":["upgradePlDataTableStateV2","getMatchingLabelColumns","deriveLabels","identity","Annotation","createColumnResolver","DataColumn","createPTableDefV2","isColumnOptional","getColumnIdAndSpec","allPColumnsReady","traverseFilterSpec","PColumnCollection","PColumnName"],"sources":["../../../../src/components/PlDataTable/createPlDataTable/createPlDataTableV2.ts"],"sourcesContent":["import type {\n  ColumnUniversalId,\n  FilterSpecNode,\n  PColumn,\n  PTableColumnIdColumn,\n  PTableSorting,\n} from \"@milaboratories/pl-model-common\";\nimport {\n  Annotation,\n  getColumnIdAndSpec,\n  isLinkerColumn,\n  PColumnName,\n} from \"@milaboratories/pl-model-common\";\nimport type {\n  AxisLabelProvider,\n  ColumnProvider,\n  PColumnDataUniversal,\n  RenderCtxBase,\n} from \"../../../render\";\nimport { allPColumnsReady, deriveLabels, PColumnCollection } from \"../../../render\";\nimport { identity } from \"es-toolkit\";\nimport type {\n  CreatePlDataTableOps,\n  PlDataTableFilters,\n  PlDataTableFilterSpecLeaf,\n  PlDataTableModel,\n} from \"../typesV8\";\nimport { upgradePlDataTableStateV2 } from \"../state-migration\";\nimport type { PlDataTableStateV2 } from \"../state-migration\";\nimport { getMatchingLabelColumns } from \"../labels\";\nimport { collectFilterSpecColumns, traverseFilterSpec } from \"../../../filters/traverse\";\nimport { createPTableDefV2 } from \"./createPTableDefV2\";\nimport { isColumnOptional } from \"./utils\";\nimport { DataColumn } from \"../../../columns\";\nimport { createColumnResolver, type ColumnResolver } from \"../columnResolver\";\nimport { isNil, type Nil } from \"@milaboratories/helpers\";\n\n/**\n * @deprecated This function is deprecated and will be removed in future. Please migrate to createPlDataTable with v3 options for improved column discovery and display configuration. See createPlDataTableOptionsV3 for details on the new options format and migration guidance.\n */\nexport type createPlDataTableOptionsV2 = {\n  columns: PColumn<PColumnDataUniversal>[];\n  tableState?: PlDataTableStateV2;\n  options?: CreatePlDataTableOps;\n};\n\n/**\n * Create p-table spec and handle given ui table state\n *\n * @deprecated This version of createPlDataTable is deprecated and will be removed in future. Please migrate to v3 by switching to the new options format and providing necessary information for column discovery and display configuration. See createPlDataTableOptionsV3 for details.\n * @param ctx context\n * @param columns column list\n * @param tableState table ui state\n * @returns PlAgDataTableV2 table source\n */\nexport function createPlDataTableV2<A, U>(\n  ctx: RenderCtxBase<A, U>,\n  columns: createPlDataTableOptionsV2[\"columns\"],\n  tableState?: createPlDataTableOptionsV2[\"tableState\"],\n  options?: createPlDataTableOptionsV2[\"options\"],\n): PlDataTableModel | undefined {\n  if (columns.length === 0) return undefined;\n\n  const tableStateNormalized = upgradePlDataTableStateV2(tableState);\n  const allLabelColumns = getAllLabelColumns(ctx.resultPool) ?? [];\n\n  let fullLabelColumns = getMatchingLabelColumns(columns, allLabelColumns);\n  fullLabelColumns = deriveLabels(fullLabelColumns, identity, { includeNativeLabel: true }).map(\n    (v) => {\n      return {\n        ...v.value,\n        spec: {\n          ...v.value.spec,\n          annotations: {\n            ...v.value.spec.annotations,\n            [Annotation.Label]: v.label,\n          },\n        },\n      };\n    },\n  );\n\n  const fullColumns = [...columns, ...fullLabelColumns];\n\n  const resolver = createColumnResolver(\n    fullColumns.map((c) => DataColumn.fromColumn(c)),\n    { warn: ctx.logWarn.bind(ctx) },\n  );\n\n  // -- Filtering: rewrite via resolver, throw if any reference is unresolved --\n  const rawFilters = tableStateNormalized.pTableParams.filters;\n  const rawDefaultFilters = options?.filters ?? undefined;\n  const filters = remapFiltersThrowing(rawFilters, resolver, \"filter\");\n  const defaultFilters = remapFiltersThrowing(\n    rawDefaultFilters ?? null,\n    resolver,\n    \"default filter\",\n  );\n\n  // -- Sorting: rewrite via resolver, throw if any reference is unresolved --\n  const userSorting = tableStateNormalized.pTableParams.sorting;\n  const rawSorting = (isNil(userSorting) ? options?.sorting : userSorting) ?? [];\n  const sorting = remapSortingThrowing(rawSorting, resolver);\n\n  const coreJoinType = options?.coreJoinType ?? \"full\";\n  const fullDef = createPTableDefV2({\n    columns,\n    labelColumns: fullLabelColumns,\n    coreJoinType,\n    filters: filters ?? null,\n    sorting,\n    coreColumnPredicate: options?.coreColumnPredicate,\n  });\n\n  const fullHandle = ctx.createPTableV2(fullDef);\n  const pframeHandle = ctx.createPFrame(fullColumns);\n  if (!fullHandle || !pframeHandle) return undefined;\n\n  const hiddenColumns = new Set<ColumnUniversalId>(\n    ((): ColumnUniversalId[] => {\n      // Inner join works as a filter - all columns must be present\n      if (coreJoinType === \"inner\") return [];\n\n      const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;\n      if (hiddenColIds !== null) {\n        return hiddenColIds\n          .filter((s): s is PTableColumnIdColumn => s.type === \"column\")\n          .map((s) => s.id);\n      }\n\n      return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);\n    })(),\n  );\n\n  // Preserve linker columns\n  columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));\n\n  // Preserve core columns as they change the shape of join.\n  const coreColumnPredicate = options?.coreColumnPredicate;\n  if (coreColumnPredicate) {\n    const coreColumns = columns.flatMap((c) =>\n      coreColumnPredicate(getColumnIdAndSpec(c)) ? [c.id] : [],\n    );\n    coreColumns.forEach((c) => hiddenColumns.delete(c));\n  }\n\n  // Preserve sorted columns from being hidden\n  sorting\n    .map((s) => s.column)\n    .filter((c): c is PTableColumnIdColumn => c.type === \"column\")\n    .forEach((c) => hiddenColumns.delete(c.id));\n\n  // Preserve filter columns from being hidden\n  if (filters) {\n    collectFilterSpecColumns(filters)\n      .flatMap((c) => (c.type === \"column\" ? [c.id] : []))\n      .forEach((c) => hiddenColumns.delete(c));\n  }\n\n  const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));\n  const visibleLabelColumns = getMatchingLabelColumns(\n    visibleColumns.map(getColumnIdAndSpec),\n    allLabelColumns,\n  );\n\n  // if at least one column is not yet computed, we can't show the table\n  if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns])) return undefined;\n\n  const visibleDef = createPTableDefV2({\n    columns: visibleColumns,\n    labelColumns: visibleLabelColumns,\n    coreJoinType,\n    filters: filters ?? null,\n    sorting,\n    coreColumnPredicate,\n  });\n  const visibleHandle = ctx.createPTableV2(visibleDef);\n\n  if (!visibleHandle) return undefined;\n\n  return {\n    sourceId: tableStateNormalized.pTableParams.sourceId,\n    fullTableHandle: fullHandle,\n    fullPframeHandle: pframeHandle,\n    visibleTableHandle: visibleHandle,\n    defaultFilters: defaultFilters ?? undefined,\n  } satisfies PlDataTableModel;\n}\n\n/** Rewrite filter column refs through the resolver; throw on any unresolved ref. */\nfunction remapFiltersThrowing(\n  filters: Nil | PlDataTableFilters,\n  resolver: ColumnResolver,\n  label: string,\n): Nil | PlDataTableFilters {\n  if (isNil(filters)) return filters;\n\n  type Node = FilterSpecNode<PlDataTableFilterSpecLeaf>;\n  return traverseFilterSpec(filters, {\n    leaf: (leaf): Node => {\n      if (leaf.type === undefined) return leaf;\n      const result = { ...leaf };\n      if (\"column\" in result) {\n        const c = resolver(result.column);\n        if (isNil(c))\n          throw new Error(\n            `Invalid ${label} column ${JSON.stringify(result.column)}: column reference does not match the table columns`,\n          );\n        result.column = c;\n      }\n      if (\"rhs\" in result) {\n        const c = resolver(result.rhs);\n        if (isNil(c))\n          throw new Error(\n            `Invalid ${label} column ${JSON.stringify(result.rhs)}: column reference does not match the table columns`,\n          );\n        result.rhs = c;\n      }\n      return result;\n    },\n    and: (results): Node => ({ type: \"and\", filters: results }),\n    or: (results): Node => ({ type: \"or\", filters: results }),\n    not: (result): Node => ({ type: \"not\", filter: result }),\n  }) as PlDataTableFilters;\n}\n\n/** Rewrite sorting column refs through the resolver; throw on any unresolved ref. */\nfunction remapSortingThrowing(sorting: PTableSorting[], resolver: ColumnResolver): PTableSorting[] {\n  return sorting.map((s) => {\n    const c = resolver(s.column);\n    if (isNil(c))\n      throw new Error(\n        `Invalid sorting column ${JSON.stringify(s.column)}: column reference does not match the table columns`,\n      );\n    return { ...s, column: c };\n  });\n}\n\nfunction getAllLabelColumns(\n  resultPool: AxisLabelProvider & ColumnProvider,\n): undefined | PColumn<undefined | PColumnDataUniversal>[] {\n  return new PColumnCollection()\n    .addAxisLabelProvider(resultPool)\n    .addColumnProvider(resultPool)\n    .getColumns(\n      {\n        name: PColumnName.Label,\n        axes: [{}], // exactly one axis\n      },\n      { dontWaitAllData: true, overrideLabelAnnotation: false },\n    );\n}\n"],"mappings":"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"}

package/dist/components/PlDataTable/createPlDataTable/createPlDataTableV2.js

@@ -2,7 +2,7 @@ import { deriveLabels } from "../../../render/util/label.js";
 import { allPColumnsReady } from "../../../render/util/pcolumn_data.js";
 import { PColumnCollection } from "../../../render/util/column_collection.js";
 import "../../../render/index.js";
-import { ColumnLazyImpl } from "../../../columns/column_lazy.js";
+import { DataColumn } from "../../../columns/data_column.js";
 import "../../../columns/index.js";
 import { collectFilterSpecColumns, traverseFilterSpec } from "../../../filters/traverse.js";
 import { upgradePlDataTableStateV2 } from "../state-migration.js";
@@ -41,7 +41,7 @@ function createPlDataTableV2(ctx, columns, tableState, options) {
 		};
 	});
 	const fullColumns = [...columns, ...fullLabelColumns];
-	const resolver = createColumnResolver(fullColumns.map((c) => ColumnLazyImpl.fromColumn(c)), { warn: ctx.logWarn.bind(ctx) });
+	const resolver = createColumnResolver(fullColumns.map((c) => DataColumn.fromColumn(c)), { warn: ctx.logWarn.bind(ctx) });
 	const rawFilters = tableStateNormalized.pTableParams.filters;
 	const rawDefaultFilters = options?.filters ?? void 0;
 	const filters = remapFiltersThrowing(rawFilters, resolver, "filter");