@platforma-sdk/model 1.79.24 → 1.80.0

package/dist/columns/index.d.ts

@@ -1,7 +1,15 @@
-import { ColumnSelector, RelaxedAxisSelector, RelaxedColumnSelector, RelaxedRecord, RelaxedStringMatchers, StringMatcher, convertColumnSelectorToMultiColumnSelector, convertRelaxedAxisSelectorToMultiAxisSelector, convertRelaxedColumnSelectorToMultiColumnSelector } from "./column_selector.js";
-import { ColumnData, ColumnDataStatus, ColumnSnapshot, createColumnSnapshot, createReadyColumnData } from "./column_snapshot.js";
-import { ArrayColumnProvider, ColumnSnapshotProvider, ColumnSource, OutputColumnProvider, OutputColumnProviderOpts, SnapshotColumnProvider, isColumnSnapshotProvider, toColumnSnapshotProvider } from "./column_snapshot_provider.js";
-import { AnchorEntry, AnchoredBuildOptions, AnchoredColumnCollection, AnchoredFindColumnsOptions, BuildOptions, ColumnCollection, ColumnCollectionBuilder, ColumnMatch, ColumnVariant, FindColumnsOptions, MatchQualifications, MatchVariant, MatchingMode } from "./column_collection_builder.js";
-import { ResultPoolColumnSnapshotProvider, collectCtxColumnSnapshotProviders } from "./ctx_column_sources.js";
-import { ExpandByPartitionOpts, ExpandByPartitionResult, SplitAxis, expandByPartition } from "./expand_by_partition.js";
-export { AnchorEntry, AnchoredBuildOptions, AnchoredColumnCollection, AnchoredFindColumnsOptions, ArrayColumnProvider, BuildOptions, ColumnCollection, ColumnCollectionBuilder, ColumnData, ColumnDataStatus, ColumnMatch, ColumnSelector, ColumnSnapshot, ColumnSnapshotProvider, ColumnSource, ColumnVariant, ExpandByPartitionOpts, ExpandByPartitionResult, FindColumnsOptions, MatchQualifications, MatchVariant, MatchingMode, OutputColumnProvider, OutputColumnProviderOpts, RelaxedAxisSelector, RelaxedColumnSelector, RelaxedRecord, RelaxedStringMatchers, ResultPoolColumnSnapshotProvider, SnapshotColumnProvider, SplitAxis, type StringMatcher, collectCtxColumnSnapshotProviders, convertColumnSelectorToMultiColumnSelector, convertRelaxedAxisSelectorToMultiAxisSelector, convertRelaxedColumnSelectorToMultiColumnSelector, createColumnSnapshot, createReadyColumnData, expandByPartition, isColumnSnapshotProvider, toColumnSnapshotProvider };
+import { ColumnFieldStatus, ColumnRecipeId, ColumnResolutionStatus, SpecQuery } from "./column_recipes/types.js";
+import { ColumnAbsentError, ColumnLazy, ColumnLazyData, ColumnLazyId, ColumnLazyImpl, isColumnLazy } from "./column_lazy.js";
+import { ColumnDiscoveredRecipe } from "./column_recipes/column_discovered_recipe.js";
+import { ColumnFilteredRecipe } from "./column_recipes/column_filtered_recipe.js";
+import { Column, ColumnSource, isColumn } from "./column.js";
+import { ColumnOverriddenRecipe } from "./column_recipes/column_overrided_recipe.js";
+import { ColumnRecipe, isColumnRecipe } from "./column_recipes/index.js";
+import { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl } from "./column_providers/providers.js";
+import { ColumnsSource } from "./column_providers/types.js";
+import { _ctxProvidersCache, getCtxProviders, isColumnProvider, toColumnProvider } from "./column_providers/index.js";
+import { ExpandByPartitionOpts, SplitAxis, expandByPartition } from "./expand_by_partition.js";
+import { ColumnsCollection, ColumnsCollectionDeps, ColumnsCollectionImpl, ColumnsSourceShorthand, isColumnsCollection } from "./columns_collection.js";
+import { deriveAxisValuesLabels } from "./derive_axis_values_labels.js";
+import { ColumnOption, collectLinkerColumns, collectLinkerIds, deriveColumnOptions, getLeafColumnData, hasColumnData, hitQualifications, isLeafColumn, queriesQualifications } from "./utils.js";
+export { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, Column, ColumnAbsentError, ColumnDiscoveredRecipe, type ColumnFieldStatus, ColumnFilteredRecipe, ColumnLazy, ColumnLazyData, ColumnLazyId, ColumnLazyImpl, ColumnOption, ColumnOverriddenRecipe, ColumnRecipe, type ColumnRecipeId, type ColumnResolutionStatus, ColumnSource, ColumnsCollection, ColumnsCollectionDeps, ColumnsCollectionImpl, ColumnsProvider, ColumnsSource, ColumnsSourceShorthand, ExpandByPartitionOpts, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl, type SpecQuery, SplitAxis, _ctxProvidersCache, collectLinkerColumns, collectLinkerIds, deriveAxisValuesLabels, deriveColumnOptions, expandByPartition, getCtxProviders, getLeafColumnData, hasColumnData, hitQualifications, isColumn, isColumnLazy, isColumnProvider, isColumnRecipe, isColumnsCollection, isLeafColumn, queriesQualifications, toColumnProvider };

package/dist/columns/index.js

@@ -1,7 +1,13 @@
-import { createColumnSnapshot, createReadyColumnData } from "./column_snapshot.js";
-import { ArrayColumnProvider, OutputColumnProvider, SnapshotColumnProvider, isColumnSnapshotProvider, toColumnSnapshotProvider } from "./column_snapshot_provider.js";
-import { convertColumnSelectorToMultiColumnSelector, convertRelaxedAxisSelectorToMultiAxisSelector, convertRelaxedColumnSelectorToMultiColumnSelector } from "./column_selector.js";
-import { ColumnCollectionBuilder } from "./column_collection_builder.js";
-import { ResultPoolColumnSnapshotProvider, collectCtxColumnSnapshotProviders } from "./ctx_column_sources.js";
+import { Column, isColumn } from "./column.js";
+import { ColumnDiscoveredRecipe } from "./column_recipes/column_discovered_recipe.js";
+import { ColumnFilteredRecipe } from "./column_recipes/column_filtered_recipe.js";
+import { ColumnRecipe, isColumnRecipe } from "./column_recipes/index.js";
+import { ColumnOverriddenRecipe } from "./column_recipes/column_overrided_recipe.js";
+import { ColumnAbsentError, ColumnLazy, ColumnLazyImpl, isColumnLazy } from "./column_lazy.js";
+import { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl } from "./column_providers/providers.js";
+import { _ctxProvidersCache, getCtxProviders, isColumnProvider, toColumnProvider } from "./column_providers/index.js";
+import { ColumnsCollection, ColumnsCollectionImpl, isColumnsCollection } from "./columns_collection.js";
+import { collectLinkerColumns, collectLinkerIds, deriveColumnOptions, getLeafColumnData, hasColumnData, hitQualifications, isLeafColumn, queriesQualifications } from "./utils.js";
 import { expandByPartition } from "./expand_by_partition.js";
-export { ArrayColumnProvider, ColumnCollectionBuilder, OutputColumnProvider, ResultPoolColumnSnapshotProvider, SnapshotColumnProvider, collectCtxColumnSnapshotProviders, convertColumnSelectorToMultiColumnSelector, convertRelaxedAxisSelectorToMultiAxisSelector, convertRelaxedColumnSelectorToMultiColumnSelector, createColumnSnapshot, createReadyColumnData, expandByPartition, isColumnSnapshotProvider, toColumnSnapshotProvider };
+import { deriveAxisValuesLabels } from "./derive_axis_values_labels.js";
+export { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, Column, ColumnAbsentError, ColumnDiscoveredRecipe, ColumnFilteredRecipe, ColumnLazy, ColumnLazyImpl, ColumnOverriddenRecipe, ColumnRecipe, ColumnsCollection, ColumnsCollectionImpl, ColumnsProvider, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl, _ctxProvidersCache, collectLinkerColumns, collectLinkerIds, deriveAxisValuesLabels, deriveColumnOptions, expandByPartition, getCtxProviders, getLeafColumnData, hasColumnData, hitQualifications, isColumn, isColumnLazy, isColumnProvider, isColumnRecipe, isColumnsCollection, isLeafColumn, queriesQualifications, toColumnProvider };

package/dist/columns/utils.cjs

@@ -0,0 +1,186 @@
+const require_accessor = require("../render/accessor.cjs");
+const require_derive_distinct_labels = require("../labels/derive_distinct_labels.cjs");
+require("../render/index.cjs");
+const require_column_discovered_recipe = require("./column_recipes/column_discovered_recipe.cjs");
+const require_column_filtered_recipe = require("./column_recipes/column_filtered_recipe.cjs");
+const require_column_overrided_recipe = require("./column_recipes/column_overrided_recipe.cjs");
+const require_column_lazy = require("./column_lazy.cjs");
+const require_columns_collection = require("./columns_collection.cjs");
+let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
+let _milaboratories_helpers = require("@milaboratories/helpers");
+//#region src/columns/utils.ts
+/**
+* PObjectIds of every non-hit column referenced by `recipe.getQuery()`,
+* deduped in traversal order. The hit column is
+* `extractPObjectId(recipe.id)`; anything else in the query is a linker or
+* other engine-consumed column.
+*
+* Pure query walk — no registry access. Use {@link collectLinkerColumns} for
+* the resolved {@link ColumnLazy} variant.
+*/
+function collectLinkerIds(recipe) {
+	const hit = (0, _milaboratories_pl_model_common.extractPObjectId)(recipe.id);
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const id of (0, _milaboratories_pl_model_common.collectSpecQueryColumns)(recipe.getQuery())) {
+		const bare = (0, _milaboratories_pl_model_common.extractPObjectId)(id);
+		if (bare === hit) continue;
+		if (seen.has(bare)) continue;
+		seen.add(bare);
+		out.push(bare);
+	}
+	return out;
+}
+/**
+* {@link collectLinkerIds} resolved against the ambient context as
+* {@link ColumnLazy} instances. 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) => require_column_lazy.ColumnLazyImpl.fromId(id, opts) ?? (0, _milaboratories_helpers.throwError)(`materializeLinkers: linker ${id} not resolvable`));
+}
+/**
+* Hit-side axis qualifications for the recipe — the ones that should land on
+* the outer-join entry wrapping this column at the consumer boundary.
+*
+* Descends {@link ColumnOverriddenRecipe} / {@link ColumnFilteredRecipe} via
+* `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise
+* returns `[]`. Pure recipe walk — no query-tree introspection.
+*/
+function hitQualifications(recipe) {
+	return findDiscovered(recipe)?.getColumnQualifications() ?? [];
+}
+/**
+* Per-primary-column axis qualifications for the recipe — applied to the
+* outer primary anchors on this recipe's group side. Keyed by the external
+* primary column id (NOT by columns inside this recipe's own query).
+*
+* Same walk strategy as {@link hitQualifications}.
+*/
+function queriesQualifications(recipe) {
+	return findDiscovered(recipe)?.getQueriesQualifications() ?? {};
+}
+/**
+* Whether the recipe's underlying data resources actually carry bytes —
+* strictly stronger than `getDataStatus() === "present"`, which only tells
+* that the `.data` field is wired onto the accessor.
+*
+* 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
+* all of them. Inline {@link PColumnValues} payloads count as present.
+*
+* Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as
+* "not yet ready") rather than throwing — this is a UI-facing predicate, not
+* a contract assertion.
+*/
+function hasColumnData(recipe, opts = {}) {
+	for (const id of recipe.getReferencedIds()) {
+		const lazy = require_column_lazy.ColumnLazyImpl.fromId(id, opts);
+		if (lazy === void 0) return false;
+		if (lazy.getDataStatus() !== "present") return false;
+		if (!isLazyDataPresent(lazy.getData())) return false;
+	}
+	return true;
+}
+function isLazyDataPresent(data) {
+	if (data === void 0) return false;
+	if (Array.isArray(data)) return true;
+	if (data instanceof require_accessor.TreeNodeAccessor) return data.hasData();
+	if ((0, _milaboratories_pl_model_common.isDataInfo)(data)) {
+		let ok = true;
+		(0, _milaboratories_pl_model_common.visitDataInfo)(data, (blob) => {
+			ok &&= blob.hasData();
+		});
+		return ok;
+	}
+	return false;
+}
+/**
+* Walk wrapper layers (Overridden, Filtered) until a {@link
+* ColumnDiscoveredRecipe} is found. Returns `undefined` if the recipe chain
+* has no Discovered layer (bare leaves and Overridden-over-leaf cases).
+*
+* Invariant from the wrapper classes themselves: there is at most one
+* Discovered layer in any recipe chain — Discovered is constructed only via
+* its own factory and is never re-wrapped by Discovered.
+*/
+function findDiscovered(recipe) {
+	let current = recipe;
+	while (true) {
+		if (current instanceof require_column_discovered_recipe.ColumnDiscoveredRecipe) return current;
+		if (current instanceof require_column_overrided_recipe.ColumnOverriddenRecipe || current instanceof require_column_filtered_recipe.ColumnFilteredRecipe) {
+			current = current.getInner();
+			continue;
+		}
+		return;
+	}
+}
+/**
+* A recipe is a "leaf" (directly co-indexed on the anchor, reached without a
+* linker chain) iff its wrapper chain contains no {@link ColumnDiscoveredRecipe}.
+*
+* `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.
+*/
+function isLeafColumn(recipe) {
+	return findDiscovered(recipe) === void 0;
+}
+/**
+* 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`.
+*/
+function getLeafColumnData(recipe) {
+	if (!isLeafColumn(recipe)) throw new Error(`getLeafColumnData: recipe ${recipe.id} is not a leaf column`);
+	return extractLeafColumn(recipe)?.getData();
+}
+/**
+* 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}.
+*/
+function extractLeafColumn(recipe) {
+	let current = recipe;
+	while (true) {
+		if (current instanceof require_column_lazy.ColumnLazyImpl) return current;
+		if (current instanceof require_column_overrided_recipe.ColumnOverriddenRecipe || current instanceof require_column_filtered_recipe.ColumnFilteredRecipe) {
+			current = current.getInner();
+			continue;
+		}
+		if (current instanceof require_column_discovered_recipe.ColumnDiscoveredRecipe) throw new Error(`extractLeafColumn: recipe ${recipe.id} is not a leaf column`);
+		throw new Error(`extractLeafColumn: unrecognized recipe layer for ${recipe.id}`);
+	}
+}
+/**
+* Enumerates every column already in `source` and renders distinct labels
+* from each recipe's spec. Filtering is the caller's job — pass a
+* {@link ColumnsCollection} that was already narrowed via `.filter(...)` /
+* `.discover(...)`, or hand over a raw {@link ColumnsSource} (provider,
+* accessor, column array, or `"result_pool"` / `"current_block"` shorthand)
+* to be wrapped on the fly.
+*/
+function deriveColumnOptions(source, labelOptions = {}) {
+	const recipes = (require_columns_collection.isColumnsCollection(source) ? source : require_columns_collection.ColumnsCollection(source)).getColumns();
+	const labels = require_derive_distinct_labels.deriveDistinctLabels(recipes.map((r) => r.getSpec()), labelOptions);
+	return recipes.map((r, i) => ({
+		id: r.id,
+		label: labels[i]
+	}));
+}
+//#endregion
+exports.collectLinkerColumns = collectLinkerColumns;
+exports.collectLinkerIds = collectLinkerIds;
+exports.deriveColumnOptions = deriveColumnOptions;
+exports.getLeafColumnData = getLeafColumnData;
+exports.hasColumnData = hasColumnData;
+exports.hitQualifications = hitQualifications;
+exports.isLeafColumn = isLeafColumn;
+exports.queriesQualifications = queriesQualifications;
+
+//# sourceMappingURL=utils.cjs.map

package/dist/columns/utils.cjs.map

@@ -0,0 +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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"}

package/dist/columns/utils.d.ts

@@ -0,0 +1,96 @@
+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 { ColumnsSource } from "./column_providers/types.js";
+import { ColumnsCollection } from "./columns_collection.js";
+import { AxisQualification, ColumnUniversalId, PObjectId } from "@milaboratories/pl-model-common";
+
+//#region src/columns/utils.d.ts
+/**
+ * PObjectIds of every non-hit column referenced by `recipe.getQuery()`,
+ * deduped in traversal order. The hit column is
+ * `extractPObjectId(recipe.id)`; anything else in the query is a linker or
+ * other engine-consumed column.
+ *
+ * Pure query walk — no registry access. Use {@link collectLinkerColumns} for
+ * the resolved {@link ColumnLazy} 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 —
+ * matches the contract of the legacy `resolveLinkers` it replaces.
+ */
+declare function collectLinkerColumns(recipe: ColumnRecipe, opts?: {
+  ctx?: GlobalCfgRenderCtx;
+}): ColumnLazy[];
+/**
+ * Hit-side axis qualifications for the recipe — the ones that should land on
+ * the outer-join entry wrapping this column at the consumer boundary.
+ *
+ * Descends {@link ColumnOverriddenRecipe} / {@link ColumnFilteredRecipe} via
+ * `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise
+ * returns `[]`. Pure recipe walk — no query-tree introspection.
+ */
+declare function hitQualifications(recipe: ColumnRecipe): readonly AxisQualification[];
+/**
+ * Per-primary-column axis qualifications for the recipe — applied to the
+ * outer primary anchors on this recipe's group side. Keyed by the external
+ * primary column id (NOT by columns inside this recipe's own query).
+ *
+ * Same walk strategy as {@link hitQualifications}.
+ */
+declare function queriesQualifications(recipe: ColumnRecipe): Readonly<Record<PObjectId, AxisQualification[]>>;
+/**
+ * Whether the recipe's underlying data resources actually carry bytes —
+ * strictly stronger than `getDataStatus() === "present"`, which only tells
+ * that the `.data` field is wired onto the accessor.
+ *
+ * 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
+ * all of them. Inline {@link PColumnValues} payloads count as present.
+ *
+ * Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as
+ * "not yet ready") rather than throwing — this is a UI-facing predicate, not
+ * a contract assertion.
+ */
+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}.
+ *
+ * `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.
+ */
+declare function isLeafColumn(recipe: ColumnRecipe): boolean;
+/**
+ * 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`.
+ */
+declare function getLeafColumnData(recipe: ColumnRecipe): ColumnLazyData;
+/** Drop-down option built over a {@link ColumnsCollection} — universal-id valued. */
+type ColumnOption = {
+  readonly id: ColumnUniversalId;
+  readonly label: string;
+};
+/**
+ * Enumerates every column already in `source` and renders distinct labels
+ * from each recipe's spec. Filtering is the caller's job — pass a
+ * {@link ColumnsCollection} that was already narrowed via `.filter(...)` /
+ * `.discover(...)`, or hand over a raw {@link ColumnsSource} (provider,
+ * accessor, column array, or `"result_pool"` / `"current_block"` shorthand)
+ * to be wrapped on the fly.
+ */
+declare function deriveColumnOptions(source: ColumnsCollection | ColumnsSource[], labelOptions?: DeriveLabelsOptions): ColumnOption[];
+//#endregion
+export { ColumnOption, collectLinkerColumns, collectLinkerIds, deriveColumnOptions, getLeafColumnData, hasColumnData, hitQualifications, isLeafColumn, queriesQualifications };
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +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"}

package/dist/columns/utils.js

@@ -0,0 +1,179 @@
+import { TreeNodeAccessor } from "../render/accessor.js";
+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 { ColumnsCollection, isColumnsCollection } from "./columns_collection.js";
+import { collectSpecQueryColumns, extractPObjectId, isDataInfo, visitDataInfo } from "@milaboratories/pl-model-common";
+import { throwError } from "@milaboratories/helpers";
+//#region src/columns/utils.ts
+/**
+* PObjectIds of every non-hit column referenced by `recipe.getQuery()`,
+* deduped in traversal order. The hit column is
+* `extractPObjectId(recipe.id)`; anything else in the query is a linker or
+* other engine-consumed column.
+*
+* Pure query walk — no registry access. Use {@link collectLinkerColumns} for
+* the resolved {@link ColumnLazy} variant.
+*/
+function collectLinkerIds(recipe) {
+	const hit = extractPObjectId(recipe.id);
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const id of collectSpecQueryColumns(recipe.getQuery())) {
+		const bare = extractPObjectId(id);
+		if (bare === hit) continue;
+		if (seen.has(bare)) continue;
+		seen.add(bare);
+		out.push(bare);
+	}
+	return out;
+}
+/**
+* {@link collectLinkerIds} resolved against the ambient context as
+* {@link ColumnLazy} instances. 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`));
+}
+/**
+* Hit-side axis qualifications for the recipe — the ones that should land on
+* the outer-join entry wrapping this column at the consumer boundary.
+*
+* Descends {@link ColumnOverriddenRecipe} / {@link ColumnFilteredRecipe} via
+* `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise
+* returns `[]`. Pure recipe walk — no query-tree introspection.
+*/
+function hitQualifications(recipe) {
+	return findDiscovered(recipe)?.getColumnQualifications() ?? [];
+}
+/**
+* Per-primary-column axis qualifications for the recipe — applied to the
+* outer primary anchors on this recipe's group side. Keyed by the external
+* primary column id (NOT by columns inside this recipe's own query).
+*
+* Same walk strategy as {@link hitQualifications}.
+*/
+function queriesQualifications(recipe) {
+	return findDiscovered(recipe)?.getQueriesQualifications() ?? {};
+}
+/**
+* Whether the recipe's underlying data resources actually carry bytes —
+* strictly stronger than `getDataStatus() === "present"`, which only tells
+* that the `.data` field is wired onto the accessor.
+*
+* 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
+* all of them. Inline {@link PColumnValues} payloads count as present.
+*
+* Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as
+* "not yet ready") rather than throwing — this is a UI-facing predicate, not
+* a contract assertion.
+*/
+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;
+	}
+	return true;
+}
+function isLazyDataPresent(data) {
+	if (data === void 0) return false;
+	if (Array.isArray(data)) return true;
+	if (data instanceof TreeNodeAccessor) return data.hasData();
+	if (isDataInfo(data)) {
+		let ok = true;
+		visitDataInfo(data, (blob) => {
+			ok &&= blob.hasData();
+		});
+		return ok;
+	}
+	return false;
+}
+/**
+* Walk wrapper layers (Overridden, Filtered) until a {@link
+* ColumnDiscoveredRecipe} is found. Returns `undefined` if the recipe chain
+* has no Discovered layer (bare leaves and Overridden-over-leaf cases).
+*
+* Invariant from the wrapper classes themselves: there is at most one
+* Discovered layer in any recipe chain — Discovered is constructed only via
+* its own factory and is never re-wrapped by Discovered.
+*/
+function findDiscovered(recipe) {
+	let current = recipe;
+	while (true) {
+		if (current instanceof ColumnDiscoveredRecipe) return current;
+		if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {
+			current = current.getInner();
+			continue;
+		}
+		return;
+	}
+}
+/**
+* A recipe is a "leaf" (directly co-indexed on the anchor, reached without a
+* linker chain) iff its wrapper chain contains no {@link ColumnDiscoveredRecipe}.
+*
+* `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.
+*/
+function isLeafColumn(recipe) {
+	return findDiscovered(recipe) === void 0;
+}
+/**
+* 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`.
+*/
+function getLeafColumnData(recipe) {
+	if (!isLeafColumn(recipe)) throw new Error(`getLeafColumnData: recipe ${recipe.id} is not a leaf column`);
+	return extractLeafColumn(recipe)?.getData();
+}
+/**
+* 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}.
+*/
+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}`);
+	}
+}
+/**
+* Enumerates every column already in `source` and renders distinct labels
+* from each recipe's spec. Filtering is the caller's job — pass a
+* {@link ColumnsCollection} that was already narrowed via `.filter(...)` /
+* `.discover(...)`, or hand over a raw {@link ColumnsSource} (provider,
+* accessor, column array, or `"result_pool"` / `"current_block"` shorthand)
+* to be wrapped on the fly.
+*/
+function deriveColumnOptions(source, labelOptions = {}) {
+	const recipes = (isColumnsCollection(source) ? source : ColumnsCollection(source)).getColumns();
+	const labels = deriveDistinctLabels(recipes.map((r) => r.getSpec()), labelOptions);
+	return recipes.map((r, i) => ({
+		id: r.id,
+		label: labels[i]
+	}));
+}
+//#endregion
+export { collectLinkerColumns, collectLinkerIds, deriveColumnOptions, getLeafColumnData, hasColumnData, hitQualifications, isLeafColumn, queriesQualifications };
+
+//# sourceMappingURL=utils.js.map

package/dist/columns/utils.js.map

@@ -0,0 +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":";;;;;;;;;;;;;;;;;;;;AA8BA,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,GACxB;CACd,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,MAA+B;CACxD,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;;;;;;;;;;AAWA,SAAgB,aAAa,QAA+B;CAC1D,OAAO,eAAe,MAAM,MAAM,KAAA;AACpC;;;;;;;;AASA,SAAgB,kBAAkB,QAAsC;CACtE,IAAI,CAAC,aAAa,MAAM,GACtB,MAAM,IAAI,MAAM,6BAA6B,OAAO,GAAG,sBAAsB;CAE/E,OAAO,kBAAkB,MAAM,CAAC,EAAE,QAAQ;AAC5C;;;;;;;AAQA,SAAS,kBAAkB,QAA8C;CACvE,IAAI,UAAwB;CAC5B,OAAO,MAAM;EACX,IAAI,mBAAmB,gBAAgB,OAAO;EAC9C,IAAI,mBAAmB,0BAA0B,mBAAmB,sBAAsB;GACxF,UAAU,QAAQ,SAAS;GAC3B;EACF;EACA,IAAI,mBAAmB,wBACrB,MAAM,IAAI,MAAM,6BAA6B,OAAO,GAAG,sBAAsB;EAE/E,MAAM,IAAI,MAAM,oDAAoD,OAAO,IAAI;CACjF;AACF;;;;;;;;;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/PFrameForGraphs.cjs

@@ -21,6 +21,7 @@ of partially matched axis we add to pframe a copy of this column with modified a
 and modified label (with added domain values in case if more than one copy with different domains exist).
 */
 function createPFrameForGraphs(ctx, blockColumns) {
+	if (blockColumns?.some((v) => v.data === void 0)) return void 0;
 	const suitableSpec = (spec) => !isHiddenFromUIColumn(spec) && !isHiddenFromGraphColumn(spec);
 	if (!blockColumns) return ctx.createPFrame(require_columns.getAllRelatedColumns(ctx, suitableSpec));
 	return ctx.createPFrame(require_columns.getRelatedColumns(ctx, {

package/dist/components/PFrameForGraphs.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"PFrameForGraphs.cjs","names":["Annotation","getAllRelatedColumns","getRelatedColumns"],"sources":["../../src/components/PFrameForGraphs.ts"],"sourcesContent":["import type { PColumn, PColumnSpec, PFrameHandle } from \"@milaboratories/pl-model-common\";\nimport { Annotation, readAnnotationJson } from \"@milaboratories/pl-model-common\";\nimport type { PColumnDataUniversal, RenderCtxBase } from \"../render\";\nimport { getAllRelatedColumns, getRelatedColumns } from \"../pframe_utils/columns\";\nexport type { AxesVault } from \"../pframe_utils/axes\";\nexport { enrichCompatible, getAvailableWithLinkersAxes } from \"../pframe_utils/axes\";\n\nexport function isHiddenFromGraphColumn(column: PColumnSpec): boolean {\n  return !!readAnnotationJson(column, Annotation.HideDataFromGraphs);\n}\n\nexport function isHiddenFromUIColumn(column: PColumnSpec): boolean {\n  return !!readAnnotationJson(column, Annotation.HideDataFromUi);\n}\n\n/**\n The aim of createPFrameForGraphs: to create pframe with block’s columns and all compatible columns from result pool\n (including linker columns and all label columns).\n Block’s columns are added to pframe as is.\n Other columns are added basing on set of axes of block’s columns, considering available with linker columns.\n Compatible columns must have at least one axis from block’s axes set. This axis of the compatible column from\n result pool must satisfy matchAxisId (it can have less domain keys than in block’s axis, but without conflicting values\n among existing ones).\n In requests to pframe (calculateTableData) columns must have strictly the same axes. For compatibility in case\n of partially matched axis we add to pframe a copy of this column with modified axis (with filled missed domains)\n and modified label (with added domain values in case if more than one copy with different domains exist).\n */\nexport function createPFrameForGraphs<A, U>(\n  ctx: RenderCtxBase<A, U>,\n  blockColumns?: PColumn<PColumnDataUniversal>[],\n): PFrameHandle | undefined {\n  const suitableSpec = (spec: PColumnSpec) =>\n    !isHiddenFromUIColumn(spec) && !isHiddenFromGraphColumn(spec);\n  // if current block doesn't produce own columns then use all columns from result pool\n  if (!blockColumns) {\n    return ctx.createPFrame(getAllRelatedColumns(ctx, suitableSpec));\n  }\n\n  return ctx.createPFrame(\n    getRelatedColumns(ctx, { columns: blockColumns, predicate: suitableSpec }),\n  );\n}\n"],"mappings":";;;;AAOA,SAAgB,wBAAwB,QAA8B;CACpE,OAAO,CAAC,EAAA,GAAA,gCAAA,mBAAA,CAAoB,QAAQA,gCAAAA,WAAW,kBAAkB;AACnE;AAEA,SAAgB,qBAAqB,QAA8B;CACjE,OAAO,CAAC,EAAA,GAAA,gCAAA,mBAAA,CAAoB,QAAQA,gCAAAA,WAAW,cAAc;AAC/D;;;;;;;;;;;;;AAcA,SAAgB,sBACd,KACA,cAC0B;CAC1B,MAAM,gBAAgB,SACpB,CAAC,qBAAqB,IAAI,KAAK,CAAC,wBAAwB,IAAI;CAE9D,IAAI,CAAC,cACH,OAAO,IAAI,aAAaC,gBAAAA,qBAAqB,KAAK,YAAY,CAAC;CAGjE,OAAO,IAAI,aACTC,gBAAAA,kBAAkB,KAAK;EAAE,SAAS;EAAc,WAAW;CAAa,CAAC,CAC3E;AACF"}
+{"version":3,"file":"PFrameForGraphs.cjs","names":["Annotation","getAllRelatedColumns","getRelatedColumns"],"sources":["../../src/components/PFrameForGraphs.ts"],"sourcesContent":["import type { PColumn, PColumnSpec, PFrameHandle } from \"@milaboratories/pl-model-common\";\nimport { Annotation, readAnnotationJson } from \"@milaboratories/pl-model-common\";\nimport type { PColumnDataUniversal, RenderCtxBase } from \"../render\";\nimport { getAllRelatedColumns, getRelatedColumns } from \"../pframe_utils/columns\";\nexport type { AxesVault } from \"../pframe_utils/axes\";\nexport { enrichCompatible, getAvailableWithLinkersAxes } from \"../pframe_utils/axes\";\n\nexport function isHiddenFromGraphColumn(column: PColumnSpec): boolean {\n  return !!readAnnotationJson(column, Annotation.HideDataFromGraphs);\n}\n\nexport function isHiddenFromUIColumn(column: PColumnSpec): boolean {\n  return !!readAnnotationJson(column, Annotation.HideDataFromUi);\n}\n\n/**\n The aim of createPFrameForGraphs: to create pframe with block’s columns and all compatible columns from result pool\n (including linker columns and all label columns).\n Block’s columns are added to pframe as is.\n Other columns are added basing on set of axes of block’s columns, considering available with linker columns.\n Compatible columns must have at least one axis from block’s axes set. This axis of the compatible column from\n result pool must satisfy matchAxisId (it can have less domain keys than in block’s axis, but without conflicting values\n among existing ones).\n In requests to pframe (calculateTableData) columns must have strictly the same axes. For compatibility in case\n of partially matched axis we add to pframe a copy of this column with modified axis (with filled missed domains)\n and modified label (with added domain values in case if more than one copy with different domains exist).\n */\nexport function createPFrameForGraphs<A, U>(\n  ctx: RenderCtxBase<A, U>,\n  blockColumns?: PColumn<undefined | PColumnDataUniversal>[],\n): PFrameHandle | undefined {\n  if (blockColumns?.some((v) => v.data === undefined)) return undefined;\n\n  const suitableSpec = (spec: PColumnSpec) =>\n    !isHiddenFromUIColumn(spec) && !isHiddenFromGraphColumn(spec);\n  // if current block doesn't produce own columns then use all columns from result pool\n  if (!blockColumns) {\n    return ctx.createPFrame(getAllRelatedColumns(ctx, suitableSpec));\n  }\n\n  return ctx.createPFrame(\n    getRelatedColumns(ctx, { columns: blockColumns, predicate: suitableSpec }),\n  );\n}\n"],"mappings":";;;;AAOA,SAAgB,wBAAwB,QAA8B;CACpE,OAAO,CAAC,EAAA,GAAA,gCAAA,mBAAA,CAAoB,QAAQA,gCAAAA,WAAW,kBAAkB;AACnE;AAEA,SAAgB,qBAAqB,QAA8B;CACjE,OAAO,CAAC,EAAA,GAAA,gCAAA,mBAAA,CAAoB,QAAQA,gCAAAA,WAAW,cAAc;AAC/D;;;;;;;;;;;;;AAcA,SAAgB,sBACd,KACA,cAC0B;CAC1B,IAAI,cAAc,MAAM,MAAM,EAAE,SAAS,KAAA,CAAS,GAAG,OAAO,KAAA;CAE5D,MAAM,gBAAgB,SACpB,CAAC,qBAAqB,IAAI,KAAK,CAAC,wBAAwB,IAAI;CAE9D,IAAI,CAAC,cACH,OAAO,IAAI,aAAaC,gBAAAA,qBAAqB,KAAK,YAAY,CAAC;CAGjE,OAAO,IAAI,aACTC,gBAAAA,kBAAkB,KAAK;EAAE,SAAS;EAAc,WAAW;CAAa,CAAC,CAC3E;AACF"}

package/dist/components/PFrameForGraphs.d.ts

@@ -18,7 +18,7 @@ declare function isHiddenFromUIColumn(column: PColumnSpec): boolean;
  of partially matched axis we add to pframe a copy of this column with modified axis (with filled missed domains)
  and modified label (with added domain values in case if more than one copy with different domains exist).
  */
-declare function createPFrameForGraphs<A, U>(ctx: RenderCtxBase<A, U>, blockColumns?: PColumn<PColumnDataUniversal>[]): PFrameHandle | undefined;
+declare function createPFrameForGraphs<A, U>(ctx: RenderCtxBase<A, U>, blockColumns?: PColumn<undefined | PColumnDataUniversal>[]): PFrameHandle | undefined;
 //#endregion
 export { type AxesVault, createPFrameForGraphs, enrichCompatible, getAvailableWithLinkersAxes, isHiddenFromGraphColumn, isHiddenFromUIColumn };
 //# sourceMappingURL=PFrameForGraphs.d.ts.map

package/dist/components/PFrameForGraphs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PFrameForGraphs.d.ts","names":[],"sources":["../../src/components/PFrameForGraphs.ts"],"mappings":";;;;;;iBAOgB,uBAAA,CAAwB,MAAmB,EAAX,WAAW;AAAA,iBAI3C,oBAAA,CAAqB,MAAmB,EAAX,WAAW;;AAJxD;;;;AAA2D;AAI3D;;;;AAAwD;AAgBxD;iBAAgB,qBAAA,OACd,GAAA,EAAK,aAAA,CAAc,CAAA,EAAG,CAAA,GACtB,YAAA,GAAe,OAAA,CAAQ,oBAAA,MACtB,YAAA"}
+{"version":3,"file":"PFrameForGraphs.d.ts","names":[],"sources":["../../src/components/PFrameForGraphs.ts"],"mappings":";;;;;;iBAOgB,uBAAA,CAAwB,MAAmB,EAAX,WAAW;AAAA,iBAI3C,oBAAA,CAAqB,MAAmB,EAAX,WAAW;;AAJxD;;;;AAA2D;AAI3D;;;;AAAwD;AAgBxD;iBAAgB,qBAAA,OACd,GAAA,EAAK,aAAA,CAAc,CAAA,EAAG,CAAA,GACtB,YAAA,GAAe,OAAA,aAAoB,oBAAA,MAClC,YAAA"}

package/dist/components/PFrameForGraphs.js

@@ -21,6 +21,7 @@ of partially matched axis we add to pframe a copy of this column with modified a
 and modified label (with added domain values in case if more than one copy with different domains exist).
 */
 function createPFrameForGraphs(ctx, blockColumns) {
+	if (blockColumns?.some((v) => v.data === void 0)) return void 0;
 	const suitableSpec = (spec) => !isHiddenFromUIColumn(spec) && !isHiddenFromGraphColumn(spec);
 	if (!blockColumns) return ctx.createPFrame(getAllRelatedColumns(ctx, suitableSpec));
 	return ctx.createPFrame(getRelatedColumns(ctx, {