@platforma-sdk/model 1.61.1 → 1.63.0

package/src/components/PlDataTable/createPlDataTable/createPlDataTableV3.ts

@@ -41,6 +41,7 @@ import type { PlDataTableFilters, PlDataTableModel } from "../typesV5";
 import { upgradePlDataTableStateV2 } from "../state-migration";
 import type { PlDataTableStateV2 } from "../state-migration";
 import type { ColumnSource, MatchingMode } from "../../../columns";
+import { Services, type RequireServices } from "@milaboratories/pl-model-common";
 import { ColumnCollectionBuilder } from "../../../columns";
 import { isColumnSnapshotProvider } from "../../../columns/column_snapshot_provider";
 import { collectCtxColumnSnapshotProviders } from "../../../columns/ctx_column_sources";
@@ -184,8 +185,8 @@ export type createPlDataTableOptionsV3 = {
 //   | { annotation: Record<string, string> }
 //   | { ids: Set<string> };
 
-export function createPlDataTableV3<A, U>(
-  ctx: RenderCtxBase<A, U>,
+export function createPlDataTableV3<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
+  ctx: RenderCtxBase<A, U, S>,
   options: createPlDataTableOptionsV3,
 ): PlDataTableModel | undefined {
   const providers = options.source
@@ -195,170 +196,175 @@ export function createPlDataTableV3<A, U>(
   if (providers.length === 0) return undefined;
 
   // Step 1: Build collection from sources
-  const builder = new ColumnCollectionBuilder(ctx).addSources(providers);
+  const builder = new ColumnCollectionBuilder(ctx.services.pframeSpec).addSources(providers);
   const anchors = options.columns.anchors;
   const collection = isNil(anchors) ? builder.build() : builder.build({ anchors });
 
   if (!collection) return undefined;
+  try {
+    // Step 2: Get data columns, excluding annotation-hidden ones
+    const findOptions = options.columns
+      ? {
+          include: options.columns.include,
+          exclude: options.columns.exclude,
+          mode: options.columns.mode,
+          maxHops: options.columns.maxHops,
+        }
+      : undefined;
+    const findResult = collection.findColumns(findOptions);
+    const snapshots = findResult.map((v) => ("column" in v ? v.column : v));
+    const dataSnapshots = snapshots.filter((s) => !isColumnHidden(s.spec));
+    if (dataSnapshots.length === 0) return undefined;
+
+    // Convert snapshots to PColumn<PColumnDataUniversal>[]
+    const columns: PColumn<PColumnDataUniversal>[] = [];
+    for (const snap of dataSnapshots) {
+      if (!snap.data) return undefined;
+      const data = snap.data.get();
+      if (data === undefined) return undefined;
+      columns.push({ id: snap.id, spec: snap.spec, data });
+    }
 
-  // Step 2: Get data columns, excluding annotation-hidden ones
-  const findOptions = options.columns
-    ? {
-        include: options.columns.include,
-        exclude: options.columns.exclude,
-        mode: options.columns.mode,
-        maxHops: options.columns.maxHops,
-      }
-    : undefined;
-  const findResult = collection.findColumns(findOptions);
-  const snapshots = findResult.map((v) => ("column" in v ? v.column : v));
-  const dataSnapshots = snapshots.filter((s) => !isColumnHidden(s.spec));
-  if (dataSnapshots.length === 0) return undefined;
-
-  // Convert snapshots to PColumn<PColumnDataUniversal>[]
-  const columns: PColumn<PColumnDataUniversal>[] = [];
-  for (const snap of dataSnapshots) {
-    if (!snap.data) return undefined;
-    const data = snap.data.get();
-    if (data === undefined) return undefined;
-    columns.push({ id: snap.id, spec: snap.spec, data });
-  }
+    // Step 3: Normalize table state
+    const tableStateNormalized = upgradePlDataTableStateV2(options.state);
+
+    // Step 4: Get label columns from result pool and match to data columns
+    const allLabelColumns = getAllLabelColumns(ctx.resultPool);
+    if (!allLabelColumns) return undefined;
 
-  // Step 3: Normalize table state
-  const tableStateNormalized = upgradePlDataTableStateV2(options.state);
-
-  // Step 4: Get label columns from result pool and match to data columns
-  const allLabelColumns = getAllLabelColumns(ctx.resultPool);
-  if (!allLabelColumns) return undefined;
-
-  const fullLabelColumns = getMatchingLabelColumns(
-    columns.map(getColumnIdAndSpec),
-    allLabelColumns,
-  );
-
-  const fullColumns = [...columns, ...fullLabelColumns];
-
-  // Step 5: Build column ID set for filter/sorting validation
-  const fullColumnsAxes = uniqueBy(
-    fullColumns.flatMap((c) => c.spec.axesSpec.map((a) => getAxisId(a))),
-    (a) => canonicalizeJson<AxisId>(a),
-  );
-  const fullColumnsIds: PTableColumnId[] = [
-    ...fullColumnsAxes.map((a) => ({ type: "axis", id: a }) satisfies PTableColumnIdAxis),
-    ...fullColumns.map((c) => ({ type: "column", id: c.id }) satisfies PTableColumnIdColumn),
-  ];
-  const fullColumnsIdsSet = new Set(fullColumnsIds.map((c) => canonicalizeJson<PTableColumnId>(c)));
-  const isValidColumnId = (id: string): boolean =>
-    fullColumnsIdsSet.has(id as CanonicalizedJson<PTableColumnId>);
-
-  // Step 6: Filtering validation
-  const stateFilters = tableStateNormalized.pTableParams.filters;
-  const opsFilters = options?.filters ?? null;
-  const filters: null | PlDataTableFilters =
-    stateFilters != null && opsFilters != null
-      ? { type: "and", filters: [stateFilters, opsFilters] }
-      : (stateFilters ?? opsFilters);
-  const filterColumns = filters ? collectFilterSpecColumns(filters) : [];
-  const firstInvalidFilterColumn = filterColumns.find((col) => !isValidColumnId(col));
-  if (firstInvalidFilterColumn)
-    throw new Error(
-      `Invalid filter column ${firstInvalidFilterColumn}: column reference does not match the table columns`,
+    const fullLabelColumns = getMatchingLabelColumns(
+      columns.map(getColumnIdAndSpec),
+      allLabelColumns,
     );
 
-  // Step 7: Sorting validation
-  const userSorting = tableStateNormalized.pTableParams.sorting;
-  const sorting = (isEmpty(userSorting) ? options?.sorting : userSorting) ?? [];
-  const firstInvalidSortingColumn = sorting.find(
-    (s) => !isValidColumnId(canonicalizeJson<PTableColumnId>(s.column)),
-  );
-  if (firstInvalidSortingColumn)
-    throw new Error(
-      `Invalid sorting column ${JSON.stringify(firstInvalidSortingColumn.column)}: column reference does not match the table columns`,
+    const fullColumns = [...columns, ...fullLabelColumns];
+
+    // Step 5: Build column ID set for filter/sorting validation
+    const fullColumnsAxes = uniqueBy(
+      fullColumns.flatMap((c) => c.spec.axesSpec.map((a) => getAxisId(a))),
+      (a) => canonicalizeJson<AxisId>(a),
+    );
+    const fullColumnsIds: PTableColumnId[] = [
+      ...fullColumnsAxes.map((a) => ({ type: "axis", id: a }) satisfies PTableColumnIdAxis),
+      ...fullColumns.map((c) => ({ type: "column", id: c.id }) satisfies PTableColumnIdColumn),
+    ];
+    const fullColumnsIdsSet = new Set(
+      fullColumnsIds.map((c) => canonicalizeJson<PTableColumnId>(c)),
+    );
+    const isValidColumnId = (id: string): boolean =>
+      fullColumnsIdsSet.has(id as CanonicalizedJson<PTableColumnId>);
+
+    // Step 6: Filtering validation
+    const stateFilters = tableStateNormalized.pTableParams.filters;
+    const opsFilters = options?.filters ?? null;
+    const filters: null | PlDataTableFilters =
+      stateFilters != null && opsFilters != null
+        ? { type: "and", filters: [stateFilters, opsFilters] }
+        : (stateFilters ?? opsFilters);
+    const filterColumns = filters ? collectFilterSpecColumns(filters) : [];
+    const firstInvalidFilterColumn = filterColumns.find((col) => !isValidColumnId(col));
+    if (firstInvalidFilterColumn)
+      throw new Error(
+        `Invalid filter column ${firstInvalidFilterColumn}: column reference does not match the table columns`,
+      );
+
+    // Step 7: Sorting validation
+    const userSorting = tableStateNormalized.pTableParams.sorting;
+    const sorting = (isEmpty(userSorting) ? options?.sorting : userSorting) ?? [];
+    const firstInvalidSortingColumn = sorting.find(
+      (s) => !isValidColumnId(canonicalizeJson<PTableColumnId>(s.column)),
+    );
+    if (firstInvalidSortingColumn)
+      throw new Error(
+        `Invalid sorting column ${JSON.stringify(firstInvalidSortingColumn.column)}: column reference does not match the table columns`,
+      );
+
+    // Step 8: Build full table definition and handles
+    const coreJoinType = options?.coreJoinType ?? "full";
+    const fullDef = createPTableDef({
+      columns,
+      labelColumns: fullLabelColumns,
+      coreJoinType,
+      filters,
+      sorting,
+      coreColumnPredicate: options?.coreColumnPredicate,
+    });
+
+    const fullHandle = ctx.createPTableV2(fullDef);
+    const pframeHandle = ctx.createPFrame(fullColumns);
+    if (!fullHandle || !pframeHandle) return undefined;
+
+    // Step 9: Determine hidden columns
+    const hiddenColumns = new Set<PObjectId>(
+      ((): PObjectId[] => {
+        // Inner join works as a filter — all columns must be present
+        if (coreJoinType === "inner") return [];
+
+        const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;
+        if (hiddenColIds) return hiddenColIds;
+
+        return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);
+      })(),
     );
 
-  // Step 8: Build full table definition and handles
-  const coreJoinType = options?.coreJoinType ?? "full";
-  const fullDef = createPTableDef({
-    columns,
-    labelColumns: fullLabelColumns,
-    coreJoinType,
-    filters,
-    sorting,
-    coreColumnPredicate: options?.coreColumnPredicate,
-  });
-
-  const fullHandle = ctx.createPTableV2(fullDef);
-  const pframeHandle = ctx.createPFrame(fullColumns);
-  if (!fullHandle || !pframeHandle) return undefined;
-
-  // Step 9: Determine hidden columns
-  const hiddenColumns = new Set<PObjectId>(
-    ((): PObjectId[] => {
-      // Inner join works as a filter — all columns must be present
-      if (coreJoinType === "inner") return [];
-
-      const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;
-      if (hiddenColIds) return hiddenColIds;
-
-      return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);
-    })(),
-  );
-
-  // Preserve linker columns
-  columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));
-
-  // Preserve core columns as they change the shape of join
-  const coreColumnPredicate = options?.coreColumnPredicate;
-  if (coreColumnPredicate) {
-    const coreColumns = columns.flatMap((c) =>
-      coreColumnPredicate(getColumnIdAndSpec(c)) ? [c.id] : [],
+    // Preserve linker columns
+    columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));
+
+    // Preserve core columns as they change the shape of join
+    const coreColumnPredicate = options?.coreColumnPredicate;
+    if (coreColumnPredicate) {
+      const coreColumns = columns.flatMap((c) =>
+        coreColumnPredicate(getColumnIdAndSpec(c)) ? [c.id] : [],
+      );
+      coreColumns.forEach((c) => hiddenColumns.delete(c));
+    }
+
+    // Preserve sorted columns from being hidden
+    sorting
+      .map((s) => s.column)
+      .filter((c): c is PTableColumnIdColumn => c.type === "column")
+      .forEach((c) => hiddenColumns.delete(c.id));
+
+    // Preserve filter columns from being hidden
+    if (filters) {
+      collectFilterSpecColumns(filters)
+        .flatMap((c) => {
+          const obj = parseJson(c);
+          return obj.type === "column" ? [obj.id] : [];
+        })
+        .forEach((c) => hiddenColumns.delete(c));
+    }
+
+    // Step 10: Build visible table definition
+    const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
+    const visibleLabelColumns = getMatchingLabelColumns(
+      visibleColumns.map(getColumnIdAndSpec),
+      allLabelColumns,
     );
-    coreColumns.forEach((c) => hiddenColumns.delete(c));
-  }
 
-  // Preserve sorted columns from being hidden
-  sorting
-    .map((s) => s.column)
-    .filter((c): c is PTableColumnIdColumn => c.type === "column")
-    .forEach((c) => hiddenColumns.delete(c.id));
-
-  // Preserve filter columns from being hidden
-  if (filters) {
-    collectFilterSpecColumns(filters)
-      .flatMap((c) => {
-        const obj = parseJson(c);
-        return obj.type === "column" ? [obj.id] : [];
-      })
-      .forEach((c) => hiddenColumns.delete(c));
+    if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns])) return undefined;
+
+    const visibleDef = createPTableDef({
+      columns: visibleColumns,
+      labelColumns: visibleLabelColumns,
+      coreJoinType,
+      filters,
+      sorting,
+      coreColumnPredicate,
+    });
+    const visibleHandle = ctx.createPTableV2(visibleDef);
+
+    if (!visibleHandle) return undefined;
+
+    return {
+      sourceId: tableStateNormalized.pTableParams.sourceId,
+      fullTableHandle: fullHandle,
+      fullPframeHandle: pframeHandle,
+      visibleTableHandle: visibleHandle,
+    } satisfies PlDataTableModel;
+  } finally {
+    collection.dispose();
   }
-
-  // Step 10: Build visible table definition
-  const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
-  const visibleLabelColumns = getMatchingLabelColumns(
-    visibleColumns.map(getColumnIdAndSpec),
-    allLabelColumns,
-  );
-
-  if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns])) return undefined;
-
-  const visibleDef = createPTableDef({
-    columns: visibleColumns,
-    labelColumns: visibleLabelColumns,
-    coreJoinType,
-    filters,
-    sorting,
-    coreColumnPredicate,
-  });
-  const visibleHandle = ctx.createPTableV2(visibleDef);
-
-  if (!visibleHandle) return undefined;
-
-  return {
-    sourceId: tableStateNormalized.pTableParams.sourceId,
-    fullTableHandle: fullHandle,
-    fullPframeHandle: pframeHandle,
-    visibleTableHandle: visibleHandle,
-  } satisfies PlDataTableModel;
 }
 
 /** Normalize raw ColumnSource | ColumnSource[] into a flat list of sources. */

package/src/components/PlDataTable/createPlDataTable/index.ts

@@ -1,3 +1,4 @@
+import { Services, type RequireServices } from "@milaboratories/pl-model-common";
 import type { RenderCtxBase } from "../../../render";
 import type { PlDataTableModel } from "../typesV5";
 import { createPlDataTableOptionsV2, createPlDataTableV2 } from "./createPlDataTableV2";
@@ -8,12 +9,12 @@ export function createPlDataTable<A, U>(
   ctx: RenderCtxBase<A, U>,
   options: { version: "v2" } & createPlDataTableOptionsV2,
 ): ReturnType<typeof createPlDataTableV2>;
-export function createPlDataTable<A, U>(
-  ctx: RenderCtxBase<A, U>,
+export function createPlDataTable<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
+  ctx: RenderCtxBase<A, U, S>,
   options: { version?: "v3" } & createPlDataTableOptionsV3,
 ): ReturnType<typeof createPlDataTableV3>;
-export function createPlDataTable<A, U>(
-  ctx: RenderCtxBase<A, U>,
+export function createPlDataTable<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
+  ctx: RenderCtxBase<A, U, S>,
   options:
     | ({ version: "v2" } & createPlDataTableOptionsV2)
     | ({ version?: "v3" } & createPlDataTableOptionsV3),

package/src/components/PlMultiSequenceAlignment.ts

@@ -8,7 +8,6 @@ import type {
 } from "@milaboratories/pl-model-common";
 import {
   Annotation,
-  isPTableAbsent,
   PColumnName,
   stringifyJson,
   uniquePlId,
@@ -56,7 +55,7 @@ export function createRowSelectionColumn({
     return;
   }
   const data: PColumnValues = selection.selectedKeys
-    .filter((r): r is PColumnKey => r.every((v) => !isPTableAbsent(v)))
+    .filter((r): r is PColumnKey => r.every((v) => v !== null))
     .map((r) => ({ key: r, val: 1 }));
   if (!data.length) {
     return;

package/src/components/PlSelectionModel.ts

@@ -1,7 +1,7 @@
 import type { AxesSpec, PTableValueAxis } from "@milaboratories/pl-model-common";
 
 /** Key is a set of all axes values, which means it is unique across rows */
-export type PTableKey = PTableValueAxis[];
+export type PTableKey = (PTableValueAxis | null)[];
 
 /**
  * Information on selected rows.

package/src/index.ts

@@ -54,6 +54,7 @@ export * from "./block_api_v2";
 export * from "./filters";
 export * from "./annotations";
 export * from "./pframe_utils";
+export * from "./services";
 
 // reexporting everything from SDK model
 export * from "@milaboratories/pl-model-common";

package/src/pframe_utils/index.ts

@@ -80,17 +80,13 @@ const UNIQUE_VALUES_LIMIT = 1000000;
 const sortValuesPredicate = (a: { label: string }, b: { label: string }) =>
   a.label.localeCompare(b.label, "en", { numeric: true });
 
-function convertColumnData(
-  type: ValueType,
-  response: PTableVector,
-  absentValue: number | null = null,
-): PValue[] {
+function convertColumnData(type: ValueType, response: PTableVector): PValue[] {
   if (type === "String") {
     return response.data as PValue[];
   }
   const res: PValue[] = new Array(response.data.length);
   for (let i = 0; i < response.data.length; i++) {
-    res[i] = pTableValue(response, i, { absent: absentValue, na: null }) as PValue;
+    res[i] = pTableValue(response, i) as PValue;
   }
   return res;
 }

package/src/platforma.ts

@@ -9,6 +9,7 @@ import type {
   OutputWithStatus,
 } from "@milaboratories/pl-model-common";
 import type { SdkInfo } from "./version";
+import type { ServiceDispatch, UiServices as AllUiServices } from "@milaboratories/pl-model-common";
 import type { BlockStatePatch } from "./block_state_patch";
 import type { PluginRecord } from "./block_model";
 import type { PluginHandle, PluginFactoryLike } from "./plugin_handle";
@@ -54,13 +55,18 @@ export interface PlatformaV3<
   >,
   Href extends `/${string}` = `/${string}`,
   Plugins extends Record<string, unknown> = Record<string, unknown>,
+  UiServices extends Partial<AllUiServices> = Partial<AllUiServices>,
 >
   extends BlockApiV3<Data, Args, Outputs, Href>, DriverKit {
   /** Information about SDK version current platforma environment was compiled with. */
   readonly sdkInfo: SdkInfo;
   readonly apiVersion: 3;
+  /** Service dispatch — lists available services, their methods, and invokes them. */
+  readonly serviceDispatch: ServiceDispatch;
   /** @internal Type brand for plugin type inference. Not used at runtime. */
   readonly __pluginsBrand?: Plugins;
+  /** @internal Type brand for UI service type inference. Not used at runtime. */
+  readonly __uiServicesBrand?: UiServices;
 }
 
 export type Platforma<
@@ -148,7 +154,13 @@ export type InferPluginData<Pl, PluginId extends string> =
  * because PluginRecord doesn't carry Config (lost after factory.create()).
  */
 export type InferPluginHandles<T extends Record<string, unknown>> = {
-  readonly [K in keyof T]: T[K] extends PluginRecord<infer Data, infer Params, infer Outputs>
-    ? { handle: PluginHandle<PluginFactoryLike<Data, Params, Outputs>> }
+  readonly [K in keyof T]: T[K] extends PluginRecord<
+    infer Data,
+    infer Params,
+    infer Outputs,
+    infer ModelServices,
+    infer UiServices
+  >
+    ? { handle: PluginHandle<PluginFactoryLike<Data, Params, Outputs, ModelServices, UiServices>> }
     : never;
 };

package/src/plugin_handle.ts

@@ -23,37 +23,55 @@ export interface PluginFactoryLike<
   Data extends Record<string, unknown> = Record<string, unknown>,
   Params extends undefined | Record<string, unknown> = undefined | Record<string, unknown>,
   Outputs extends Record<string, unknown> = Record<string, unknown>,
+  ModelServices = unknown,
+  UiServices = unknown,
 > {
   readonly __types?: {
     data: Data;
     params: Params;
     outputs: Outputs;
+    modelServices: ModelServices;
+    uiServices: UiServices;
   };
 }
 
 /** Extract the Data type from a PluginFactoryLike phantom. */
 export type InferFactoryData<F extends PluginFactoryLike> = NonNullable<
-  F extends PluginFactoryLike<infer D, any, any> ? D : Record<string, unknown>
+  F extends PluginFactoryLike<infer D, any, any, any, any> ? D : Record<string, unknown>
 >;
 
 /** Extract the Params type from a PluginFactoryLike phantom. */
 export type InferFactoryParams<F extends PluginFactoryLike> = NonNullable<
-  F extends PluginFactoryLike<any, infer P, any> ? P : undefined
+  F extends PluginFactoryLike<any, infer P, any, any, any> ? P : undefined
 >;
 
 /** Extract the Outputs type from a PluginFactoryLike phantom. */
 export type InferFactoryOutputs<F extends PluginFactoryLike> = NonNullable<
-  F extends PluginFactoryLike<any, any, infer O> ? O : Record<string, unknown>
+  F extends PluginFactoryLike<any, any, infer O, any, any> ? O : Record<string, unknown>
 >;
 
+/** Extract the pre-resolved model services type from a PluginFactoryLike phantom. */
+export type InferFactoryModelServices<F extends PluginFactoryLike> =
+  F extends PluginFactoryLike<any, any, any, infer ModelServices, any> ? ModelServices : {};
+
+/** Extract the pre-resolved UI services type from a PluginFactoryLike phantom. */
+export type InferFactoryUiServices<F extends PluginFactoryLike> =
+  F extends PluginFactoryLike<any, any, any, any, infer UiServices> ? UiServices : {};
+
 /**
  * Derive a typed PluginHandle from a PluginFactory type.
- * Normalizes the brand to only data/params/outputs (strips config) so handles
+ * Normalizes the brand to data/params/outputs/services (strips config) so handles
  * from InferPluginHandles match handles from InferPluginHandle.
  */
 export type InferPluginHandle<F extends PluginFactoryLike> = NonNullable<
-  F extends PluginFactoryLike<infer Data, infer Params, infer Outputs>
-    ? PluginHandle<PluginFactoryLike<Data, Params, Outputs>>
+  F extends PluginFactoryLike<
+    infer Data,
+    infer Params,
+    infer Outputs,
+    infer ModelServices,
+    infer UiServices
+  >
+    ? PluginHandle<PluginFactoryLike<Data, Params, Outputs, ModelServices, UiServices>>
     : PluginHandle
 >;