@platforma-sdk/model 1.79.27 → 1.80.2

package/src/columns/column_snapshot.ts

@@ -1,58 +0,0 @@
-import type { PColumnSpec, PObjectId, SUniversalPColumnId } from "@milaboratories/pl-model-common";
-import type { PColumnDataUniversal } from "../render/internal";
-
-// --- ColumnSnapshot ---
-
-/** Data status of a column snapshot. */
-export type ColumnDataStatus = "ready" | "computing" | "absent";
-
-/**
- * Immutable snapshot of a column: spec, data status, and lazy data accessor.
- *
- * - `dataStatus` is readable without marking the render context unstable.
- * - `data` holds an active object when data exists (ready or computing),
- *   or `undefined` when data is permanently absent.
- */
-export interface ColumnSnapshot<
-  Id extends PObjectId | SUniversalPColumnId,
-  Data = PColumnDataUniversal,
-> {
-  readonly id: Id;
-  readonly spec: PColumnSpec;
-  readonly dataStatus: ColumnDataStatus;
-
-  /**
-   * Lazy data accessor.
-   * - `'ready'`: `data.get()` returns column data, context stays stable.
-   * - `'computing'`: `data.get()` returns `undefined`, marks context unstable.
-   * - `'absent'`: `data` is `undefined` — no active object, no instability.
-   */
-  readonly data: ColumnData<Data> | undefined;
-}
-
-// --- ColumnData ---
-
-/**
- * Active object wrapping lazy column data access.
- * Accessing data on a computing column marks the render context unstable.
- */
-export interface ColumnData<Data = PColumnDataUniversal> {
-  get(): Data | undefined;
-}
-
-/** Creates a ColumnData active object for a ready column. */
-export function createReadyColumnData(getData: () => PColumnDataUniversal | undefined): ColumnData {
-  return { get: getData };
-}
-
-// --- Snapshot construction helpers ---
-
-/** Creates a ColumnSnapshot from parts. */
-export function createColumnSnapshot<Id extends PObjectId>(
-  id: Id,
-  spec: PColumnSpec,
-  data: undefined | ColumnData,
-  dataStatus: ColumnDataStatus,
-): ColumnSnapshot<Id> {
-  return { id, spec, data, dataStatus };
-}

package/src/columns/column_snapshot_provider.ts

@@ -1,194 +0,0 @@
-import type { PObjectId } from "@milaboratories/pl-model-common";
-import { isDataInfo, PColumn, visitDataInfo } from "@milaboratories/pl-model-common";
-import { TreeNodeAccessor } from "../render/accessor";
-import type { PColumnDataUniversal } from "../render/internal";
-import type { ColumnDataStatus, ColumnSnapshot } from "./column_snapshot";
-
-/**
- * Data source interface for column enumeration.
- *
- * Knows nothing about the render framework, stability tracking, labels,
- * anchoring, or splitting. All that complexity lives in the collection layer.
- */
-export interface ColumnSnapshotProvider {
-  /** Returns all currently known columns. */
-  getAllColumns(): ColumnSnapshot<PObjectId>[];
-
-  /** Whether the provider has finished enumerating all its columns.
-   *  Calling this may mark the render context unstable — it touches
-   *  the reactive tree to check field resolution state. */
-  isColumnListComplete(): boolean;
-}
-
-/**
- * Union of types that can serve as column sources for helpers and builders.
- * Does NOT include TreeNodeAccessor — call `.toColumnSource()` on it first.
- */
-export type ColumnSource =
-  | ColumnSnapshotProvider
-  | ColumnSnapshot<PObjectId>[]
-  | PColumn<PColumnDataUniversal | undefined>[];
-
-/**
- * Simple provider wrapping an array of PColumns.
- * Always complete, data status always 'ready'.
- */
-export class ArrayColumnProvider implements ColumnSnapshotProvider {
-  private readonly columns: ColumnSnapshot<PObjectId>[];
-
-  constructor(columns: PColumn<PColumnDataUniversal | undefined>[]) {
-    this.columns = columns.map((col) => ({
-      id: col.id,
-      spec: col.spec,
-      data: { get: () => col.data },
-      dataStatus: this.getStatus(col.data),
-    }));
-  }
-
-  getAllColumns(): ColumnSnapshot<PObjectId>[] {
-    return this.columns;
-  }
-
-  isColumnListComplete(): boolean {
-    return true;
-  }
-
-  protected getStatus(
-    d: undefined | PColumnDataUniversal | (() => undefined | PColumnDataUniversal),
-  ): ColumnDataStatus {
-    if (d == null) {
-      return "absent";
-    }
-    if (typeof d === "function") {
-      return this.getStatus(d());
-    }
-    if (d instanceof TreeNodeAccessor) {
-      if (d.getIsReadyOrError()) return "ready";
-      if (d.getIsFinal()) return "absent";
-      return "computing";
-    }
-    if (isDataInfo(d)) {
-      let ready = true;
-      let final = true;
-      visitDataInfo(d, (v) => {
-        ready &&= v.getIsReadyOrError();
-        final &&= v.getIsFinal();
-      });
-      if (ready) return "ready";
-      if (final) return "absent";
-      return "computing";
-    }
-    return "ready";
-  }
-}
-
-/**
- * Provider wrapping an array of ColumnSnapshots.
- * Always complete. Data status taken from each snapshot.
- */
-export class SnapshotColumnProvider implements ColumnSnapshotProvider {
-  constructor(private readonly snapshots: ColumnSnapshot<PObjectId>[]) {}
-
-  getAllColumns(): ColumnSnapshot<PObjectId>[] {
-    return this.snapshots;
-  }
-
-  isColumnListComplete(): boolean {
-    return true;
-  }
-}
-
-export interface OutputColumnProviderOpts {
-  /** When true and the accessor is final, columns with no ready data get status 'absent'. */
-  allowPermanentAbsence?: boolean;
-}
-
-/**
- * Provider wrapping a TreeNodeAccessor (output/prerun resolve result).
- * Detects data status from accessor readiness state.
- */
-export class OutputColumnProvider implements ColumnSnapshotProvider {
-  constructor(
-    private readonly accessor: TreeNodeAccessor,
-    private readonly opts?: OutputColumnProviderOpts,
-  ) {}
-
-  getAllColumns(): ColumnSnapshot<PObjectId>[] {
-    return this.getColumns();
-  }
-
-  isColumnListComplete(): boolean {
-    return this.accessor.getInputsLocked();
-  }
-
-  private getColumns(): ColumnSnapshot<PObjectId>[] {
-    const pColumns = this.accessor.getPColumns();
-    if (pColumns === undefined) return [];
-
-    const isFinal = this.accessor.getIsFinal();
-    const allowAbsence = this.opts?.allowPermanentAbsence === true;
-
-    return pColumns.map((col) => {
-      const dataAccessor = col.data;
-      const isReady = dataAccessor.getIsReadyOrError();
-
-      let dataStatus: ColumnDataStatus;
-      if (isReady) {
-        dataStatus = "ready";
-      } else if (allowAbsence && isFinal) {
-        dataStatus = "absent";
-      } else {
-        dataStatus = "computing";
-      }
-
-      return {
-        id: col.id,
-        spec: col.spec,
-        dataStatus,
-        data: { get: () => (isReady ? dataAccessor : undefined) },
-      };
-    });
-  }
-}
-
-/** Checks if a value is a ColumnSnapshotProvider (duck-typing). */
-export function isColumnSnapshotProvider(source: unknown): source is ColumnSnapshotProvider {
-  return (
-    typeof source === "object" &&
-    source !== null &&
-    "getAllColumns" in source &&
-    "isColumnListComplete" in source &&
-    typeof (source as ColumnSnapshotProvider).getAllColumns === "function" &&
-    typeof (source as ColumnSnapshotProvider).isColumnListComplete === "function"
-  );
-}
-
-/** Checks if a value looks like a PColumn (has id, spec, data). */
-function isPColumnArray(source: unknown): source is PColumn<PColumnDataUniversal | undefined>[] {
-  if (!Array.isArray(source)) return false;
-  if (source.length === 0) return true; // empty array — treat as PColumn[]
-  const first = source[0];
-  return "id" in first && "spec" in first && "data" in first && !("dataStatus" in first);
-}
-
-/** Checks if a value looks like a ColumnSnapshot array. */
-function isColumnSnapshotArray(source: unknown): source is ColumnSnapshot<PObjectId>[] {
-  if (!Array.isArray(source)) return false;
-  if (source.length === 0) return true; // empty array — treat as snapshots
-  const first = source[0];
-  return "id" in first && "spec" in first && "dataStatus" in first;
-}
-
-/**
- * Normalize any ColumnSource into a ColumnSnapshotProvider.
- * - ColumnSnapshotProvider → returned as-is
- * - ColumnSnapshot<PObjectId>[] → wrapped in SnapshotColumnProvider
- * - PColumn[] → wrapped in ArrayColumnProvider
- */
-export function toColumnSnapshotProvider(source: ColumnSource): ColumnSnapshotProvider {
-  if (isColumnSnapshotProvider(source)) return source;
-  if (isColumnSnapshotArray(source)) return new SnapshotColumnProvider(source);
-  if (isPColumnArray(source)) return new ArrayColumnProvider(source);
-  // Should not reach here given the type union, but be safe
-  throw new Error("Unknown ColumnSource type");
-}

package/src/columns/ctx_column_sources.ts

@@ -1,99 +0,0 @@
-import type { PColumnSpec, PObjectId } from "@milaboratories/pl-model-common";
-import { TreeNodeAccessor } from "../render/accessor";
-import type { RenderCtxBase, ResultPool } from "../render";
-import type { ColumnSnapshot } from "./column_snapshot";
-import type { ColumnDataStatus } from "./column_snapshot";
-import type { ColumnSnapshotProvider } from "./column_snapshot_provider";
-import { OutputColumnProvider } from "./column_snapshot_provider";
-import { ResourceTypeName } from "@milaboratories/pl-model-common";
-import type { ValueOf } from "@milaboratories/helpers";
-
-/**
- * Collect ColumnSnapshotProviders from `outputs`, `prerun`, and
- * `resultPool` in that order. Dedup keeps the first occurrence per
- * `NativePObjectId`, so a block re-publishing its own columns keeps
- * the `outputs`-rooted canonical id instead of the result-pool variant.
- */
-export function collectCtxColumnSnapshotProviders(ctx: RenderCtxBase): ColumnSnapshotProvider[] {
-  const providers: ColumnSnapshotProvider[] = [];
-
-  const outputs = ctx.outputs;
-  if (outputs) {
-    providers.push(...collectPFrameProviders(outputs));
-  }
-
-  const prerun = ctx.prerun;
-  if (prerun) {
-    providers.push(...collectPFrameProviders(prerun));
-  }
-
-  providers.push(new ResultPoolColumnSnapshotProvider(ctx.resultPool));
-
-  return providers;
-}
-
-/**
- * Adapter wrapping ResultPool into the new ColumnSnapshotProvider interface.
- *
- * - `isColumnListComplete()` always returns true — the result pool
- *   is a stable snapshot within a single render cycle.
- * - Data status is derived from the underlying TreeNodeAccessor:
- *   ready (getIsReadyOrError), computing, or absent (no data resource).
- */
-export class ResultPoolColumnSnapshotProvider implements ColumnSnapshotProvider {
-  constructor(private readonly pool: ResultPool) {}
-
-  getAllColumns(): ColumnSnapshot<PObjectId>[] {
-    const pColumns = this.pool.selectColumns(() => true);
-    return pColumns.map((col) => toSnapshot(col.id, col.spec, col.data));
-  }
-
-  isColumnListComplete(): boolean {
-    return true;
-  }
-}
-
-function toSnapshot(
-  id: PObjectId,
-  spec: PColumnSpec,
-  accessor: TreeNodeAccessor | undefined,
-): ColumnSnapshot<PObjectId> {
-  if (accessor === undefined) {
-    return { id, spec, dataStatus: "absent" as ColumnDataStatus, data: undefined };
-  }
-  const isReady = accessor.getIsReadyOrError();
-  return {
-    id,
-    spec,
-    dataStatus: (isReady ? "ready" : "computing") as ColumnDataStatus,
-    data: { get: () => (isReady ? accessor : undefined) },
-  };
-}
-
-/**
- * Recursively walk the output tree starting from `accessor`.
- * - If a node's resourceType is PFrame → wrap it as OutputColumnProvider.
- * - If a node's resourceType is StdMap/std/map → recurse into its output fields.
- * - Otherwise → skip (leaf of unknown type).
- */
-function collectPFrameProviders(accessor: TreeNodeAccessor): ColumnSnapshotProvider[] {
-  const out: ColumnSnapshotProvider[] = [];
-  walkTree(accessor, out);
-  return out;
-}
-
-function walkTree(node: TreeNodeAccessor, out: ColumnSnapshotProvider[]): void {
-  const typeName = node.resourceType.name as ValueOf<typeof ResourceTypeName>;
-
-  if (typeName === ResourceTypeName.PFrame) {
-    out.push(new OutputColumnProvider(node));
-    return;
-  }
-
-  if (typeName === ResourceTypeName.StdMap || typeName === ResourceTypeName.StdMapSlash) {
-    for (const field of node.listInputFields()) {
-      const child = node.resolve(field);
-      if (child) walkTree(child, out);
-    }
-  }
-}