@platforma-sdk/ui-vue 1.79.34 → 1.80.0

package/src/components/PlAgDataTable/sources/table-source-v2.ts

@@ -1,5 +1,7 @@
 import type {
+  AnnotationDataStatus,
   AxesSpec,
+  PlDataTableColumnsMeta,
   PTableColumnId,
   PTableColumnSpecAxis,
   PTableColumnSpecColumn,
@@ -50,10 +52,6 @@ import { isJsonEqual } from "@milaboratories/helpers";
 import type { DeferredCircular } from "./focus-row";
 import { isNil, uniq } from "es-toolkit";
 
-export function isLabelColumn(column: PTableColumnSpec): column is PTableColumnSpecColumn {
-  return column.type === "column" && isLabelColumnSpec(column.spec);
-}
-
 /** Convert columnar data from the driver to rows, used by ag-grid */
 function columns2rows(
   fields: number[],
@@ -88,6 +86,7 @@ export async function calculateGridOptions({
   sheets,
   fullTableHandle,
   visibleTableHandle,
+  columnsMeta,
   dataRenderedTracker,
   hiddenColIds,
   cellButtonAxisParams,
@@ -97,6 +96,8 @@ export async function calculateGridOptions({
   generation: Ref<number>;
   fullTableHandle: PTableHandle;
   visibleTableHandle: PTableHandle;
+  /** Sidecar display metadata (label/visibility/order/status/hidden axes) from the model. */
+  columnsMeta?: PlDataTableColumnsMeta;
   dataRenderedTracker: DeferredCircular<GridApi<PlAgDataTableV2Row>>;
   hiddenColIds?: PlTableColumnIdJson[];
   cellButtonAxisParams?: PlAgCellButtonAxisParams;
@@ -108,13 +109,19 @@ export async function calculateGridOptions({
   const stateGeneration = generation.value;
 
   // get specs of the full table
-  const [tableSpecs, visibleTableSpecs] = await Promise.all([
+  const [rawTableSpecs, rawVisibleTableSpecs] = await Promise.all([
     pfDriver.getSpec(fullTableHandle),
     pfDriver.getSpec(visibleTableHandle),
   ]);
 
   if (stateGeneration !== generation.value) throw new Error("table state generation changed");
 
+  // Engine specs flow through untouched; readers below merge `columnsMeta` at
+  // their use sites via the `effective*` helpers — keeps spec === what the
+  // engine produced (matters for `colDef.context` consumers).
+  const tableSpecs = rawTableSpecs;
+  const visibleTableSpecs = rawVisibleTableSpecs;
+
   // index mapping from full specs to visible subset (hidden columns → -1)
   const specsToVisibleSpecsMapping = buildSpecsToVisibleSpecsMapping(tableSpecs, visibleTableSpecs);
 
@@ -125,18 +132,33 @@ export async function calculateGridOptions({
 
   // displayable column indices ordered: axes first, then columns by OrderPriority
   const fields = sortIndicesByTypeAndPriority(
-    selectDisplayableIndices(tableSpecs, isPartitionedAxis, getLabelColumnIndex),
+    selectDisplayableIndices(tableSpecs, isPartitionedAxis, getLabelColumnIndex, columnsMeta),
     tableSpecs,
+    columnsMeta,
   );
 
   // default hidden columns derived from Optional annotation when no saved state
-  const resolvedHiddenColIds = hiddenColIds ?? computeDefaultHiddenColIds(fields, tableSpecs);
+  const resolvedHiddenColIds =
+    hiddenColIds ?? computeDefaultHiddenColIds(fields, tableSpecs, columnsMeta);
 
   const columnDefs: ColDef<PlAgDataTableV2Row, PTableValue | PTableHidden>[] = [
     makeRowNumberColDef(),
-    ...fields.map((field) =>
-      makeColDef(field, tableSpecs[field], resolvedHiddenColIds, cellButtonAxisParams),
-    ),
+    ...fields.map((field) => {
+      const spec = tableSpecs[field];
+      // Only visible columns get a status (hidden columns → undefined → no
+      // "computing/absent" placeholder rendering).
+      const visible = (specsToVisibleSpecsMapping.get(field) ?? -1) >= 0;
+      const status =
+        visible && spec.type === "column" ? columnsMeta?.columns[spec.id]?.status : undefined;
+      return makeColDef({
+        iCol: field,
+        spec,
+        dataStatus: status,
+        hiddenColIds: resolvedHiddenColIds,
+        cellButtonAxisParams,
+        columnsMeta,
+      });
+    }),
   ];
 
   // axes — taken directly from visible table (always present as part of join)
@@ -229,15 +251,26 @@ export type PlAgCellButtonAxisParams = {
 /**
  * Calculates column definition for a given p-table column
  */
-export function makeColDef(
-  iCol: number,
-  spec: PTableColumnSpec,
-  hiddenColIds: PlTableColumnIdJson[] | undefined,
-  cellButtonAxisParams?: PlAgCellButtonAxisParams,
-): ColDef<PlAgDataTableV2Row, PTableValue | PTableHidden> {
+export function makeColDef({
+  iCol,
+  spec,
+  dataStatus,
+  hiddenColIds,
+  cellButtonAxisParams,
+  columnsMeta,
+}: {
+  iCol: number;
+  spec: PTableColumnSpec;
+  /** Per-column rendering status from the model; `undefined` for hidden cols. */
+  dataStatus: AnnotationDataStatus | undefined;
+  hiddenColIds: PlTableColumnIdJson[] | undefined;
+  cellButtonAxisParams?: PlAgCellButtonAxisParams;
+  /** Sidecar meta used to resolve the effective header label. */
+  columnsMeta?: PlDataTableColumnsMeta;
+}): ColDef<PlAgDataTableV2Row, PTableValue | PTableHidden> {
   const colId = canonicalizeJson<PTableColumnId>(getPTableColumnId(spec));
   const valueType = spec.type === "axis" ? spec.spec.type : spec.spec.valueType;
-  const columnRenderingSpec = getColumnRenderingSpec(spec);
+  const columnRenderingSpec = getColumnRenderingSpec(spec, dataStatus);
   const cellStyle: CellStyle = {};
   if (columnRenderingSpec.fontFamily) {
     if (columnRenderingSpec.fontFamily === "monospace") {
@@ -247,8 +280,7 @@ export function makeColDef(
       cellStyle.fontFamily = columnRenderingSpec.fontFamily;
     }
   }
-  const headerName =
-    readAnnotation(spec.spec, Annotation.Label)?.trim() ?? `Unlabeled ${spec.type} ${iCol}`;
+  const headerName = effectiveLabel(spec, columnsMeta)?.trim() ?? `Unlabeled ${spec.type} ${iCol}`;
 
   return {
     colId,
@@ -318,6 +350,70 @@ export function makeColDef(
   };
 }
 
+export function isLabelColumn(column: PTableColumnSpec): column is PTableColumnSpecColumn {
+  return column.type === "column" && isLabelColumnSpec(column.spec);
+}
+
+/**
+ * Effective column label: sidecar override wins over intrinsic spec
+ * annotation. Axes have no label override in the sidecar — they fall through
+ * to `pl7.app/label` on the axis spec.
+ */
+export function effectiveLabel(
+  spec: PTableColumnSpec,
+  meta: PlDataTableColumnsMeta | undefined,
+): string | undefined {
+  if (spec.type === "column") {
+    const override = meta?.columns[spec.id]?.label;
+    if (override !== undefined) return override;
+  }
+  return readAnnotation(spec.spec, Annotation.Label);
+}
+
+/**
+ * Effective visibility. For columns: sidecar override wins over the intrinsic
+ * `pl7.app/table/visibility` annotation. For axes: `meta.axes[id].hidden`
+ * forces hidden; otherwise the intrinsic axis annotation rules.
+ *
+ * Kept out of the spec on purpose — baking visibility into a column spec via
+ * override changes its `ColumnUniversalId`, so the same physical column reached
+ * two ways (e.g. as primary and as a discovered label) would diverge into two
+ * ids and render twice. The sidecar preserves identity; readers apply this at
+ * use sites.
+ */
+export function effectiveVisibility(
+  spec: PTableColumnSpec,
+  meta: PlDataTableColumnsMeta | undefined,
+): "default" | "optional" | "hidden" {
+  if (spec.type === "axis") {
+    if (meta?.axes[canonicalizeJson<AxisId>(getAxisId(spec.id))]?.hidden === true) return "hidden";
+  } else {
+    const override = meta?.columns[spec.id]?.visibility;
+    if (override !== undefined) return override;
+  }
+  if (isColumnHidden(spec.spec)) return "hidden";
+  if (isColumnOptional(spec.spec)) return "optional";
+  return "default";
+}
+
+/**
+ * Effective order priority — number suitable for left-to-right comparison
+ * (higher = further left). Sidecar override on columns wins over the
+ * intrinsic `pl7.app/table/orderPriority`; axes have no override.
+ * `undefined` when neither source supplied a value (consumer decides default).
+ */
+export function effectiveOrder(
+  spec: PTableColumnSpec,
+  meta: PlDataTableColumnsMeta | undefined,
+): number | undefined {
+  if (spec.type === "column") {
+    const override = meta?.columns[spec.id]?.order;
+    if (override !== undefined) return override;
+  }
+  const raw = readAnnotationJson(spec.spec, Annotation.Table.OrderPriority);
+  return raw as number | undefined;
+}
+
 /** Build index mapping from full tableSpecs to their position in visibleTableSpecs (missing → -1). */
 function buildSpecsToVisibleSpecsMapping(
   tableSpecs: PTableColumnSpec[],
@@ -370,6 +466,7 @@ function selectDisplayableIndices(
   tableSpecs: PTableColumnSpec[],
   isPartitionedAxis: (axisId: AxisId) => boolean,
   getLabelColumnIndex: (axisId: AxisId) => number,
+  meta: PlDataTableColumnsMeta | undefined,
 ): number[] {
   return tableSpecs
     .entries()
@@ -377,11 +474,12 @@ function selectDisplayableIndices(
       switch (spec.type) {
         case "axis":
           return (
-            !(getLabelColumnIndex(spec.id) > -1 ? true : isColumnHidden(spec.spec)) &&
-            !isPartitionedAxis(spec.id)
+            !(getLabelColumnIndex(spec.id) > -1
+              ? true
+              : effectiveVisibility(spec, meta) === "hidden") && !isPartitionedAxis(spec.id)
           );
         case "column":
-          return !isColumnHidden(spec.spec) && !isLinkerColumnSpec(spec.spec);
+          return effectiveVisibility(spec, meta) !== "hidden" && !isLinkerColumnSpec(spec.spec);
       }
     })
     .map(([i]) => i)
@@ -389,14 +487,15 @@ function selectDisplayableIndices(
 }
 
 /** Sort: axes first, then columns by OrderPriority annotation (higher priority = further left). */
-function sortIndicesByTypeAndPriority(indices: number[], tableSpecs: PTableColumnSpec[]): number[] {
+function sortIndicesByTypeAndPriority(
+  indices: number[],
+  tableSpecs: PTableColumnSpec[],
+  meta: PlDataTableColumnsMeta | undefined,
+): number[] {
   const priorityOf = (i: number): number => {
     const spec = tableSpecs[i];
-    const prior =
-      spec.type === "axis" || isLabelColumnSpec(spec.spec)
-        ? Infinity
-        : Number(readAnnotationJson(spec.spec, Annotation.Table.OrderPriority));
-
+    if (spec.type === "axis" || isLabelColumnSpec(spec.spec)) return Infinity;
+    const prior = Number(effectiveOrder(spec, meta));
     return isNaN(prior) ? 0 : prior;
   };
   return [...indices].sort((a, b) => priorityOf(b) - priorityOf(a));
@@ -406,12 +505,14 @@ function sortIndicesByTypeAndPriority(indices: number[], tableSpecs: PTableColum
 function computeDefaultHiddenColIds(
   fields: number[],
   tableSpecs: PTableColumnSpec[],
+  meta: PlDataTableColumnsMeta | undefined,
 ): PlTableColumnIdJson[] {
   return fields.reduce<PlTableColumnIdJson[]>((acc, field) => {
     const spec = tableSpecs[field];
-    return spec.type === "column" && isColumnOptional(spec.spec)
-      ? [...acc, canonicalizeJson<PTableColumnId>(getPTableColumnId(spec))]
-      : acc;
+    if (spec.type === "column" && effectiveVisibility(spec, meta) === "optional") {
+      acc.push(canonicalizeJson<PTableColumnId>(getPTableColumnId(spec)));
+    }
+    return acc;
   }, []);
 }
 

package/src/components/PlAgDataTable/sources/table-state-v2.ts

@@ -1,7 +1,6 @@
 import {
   createDefaultPTableParams,
   parseJson,
-  canonicalizeJson,
   upgradePlDataTableStateV2,
   type FilterSpec,
   type FilterSpecLeaf,
@@ -20,7 +19,6 @@ import {
   distillFilterSpec,
   PlDataTableFiltersWithMeta,
   getPTableColumnId,
-  CanonicalizedJson,
 } from "@platforma-sdk/model";
 import { computed, type Ref, type WritableComputedRef } from "vue";
 import type { PlDataTableSettingsV2 } from "../types";
@@ -334,16 +332,16 @@ function stripSuppressedFilters(node: PlDataTableFiltersWithMeta): PlDataTableFi
 function createSearchFilterNode(
   columns: PTableColumnSpec[],
   search: null | undefined | string,
-): null | FilterSpec<FilterSpecLeaf<CanonicalizedJson<PTableColumnId>>> {
+): null | FilterSpec<FilterSpecLeaf<PTableColumnId>> {
   const trimmed = search?.trim();
   if (isNil(trimmed) || trimmed.length === 0) return null;
 
-  const parts: FilterSpec<FilterSpecLeaf<CanonicalizedJson<PTableColumnId>>>[] = [];
+  const parts: FilterSpec<FilterSpecLeaf<PTableColumnId>>[] = [];
   const numericValue = Number(trimmed);
   const isValidNumber = trimmed.length > 0 && !isNaN(numericValue) && isFinite(numericValue);
 
   for (const col of columns) {
-    const column = canonicalizeJson<PTableColumnId>(getPTableColumnId(col));
+    const column = getPTableColumnId(col);
     const spec = col.spec;
 
     if (isStringValueType(spec)) {
@@ -406,9 +404,9 @@ function annotateNodeWithIds(
 
 function convertPartitionFiltersToFilterSpec(
   sheetsState: PlDataTableSheetState[],
-): FilterSpec<FilterSpecLeaf<CanonicalizedJson<PTableColumnId>>>[] {
+): FilterSpec<FilterSpecLeaf<PTableColumnId>>[] {
   return sheetsState.map((s) => {
-    const column = canonicalizeJson<PTableColumnId>({ type: "axis", id: s.axisId });
+    const column: PTableColumnId = { type: "axis", id: s.axisId };
     return typeof s.value === "number"
       ? { type: "equal" as const, column, x: s.value }
       : { type: "patternEquals" as const, column, value: s.value };

package/src/components/PlAgDataTable/sources/value-rendering.ts

@@ -1,5 +1,6 @@
 import {
   Annotation,
+  AnnotationDataStatus,
   PTableNA,
   readAnnotation,
   ValueType,
@@ -14,7 +15,7 @@ import type { PlAgDataTableV2Row } from "../types";
 
 export function formatSpecialValues(
   value: undefined | PTableValue | PTableHidden,
-  dataStatus: undefined | "absent" | "error" | "computing" | "ready",
+  dataStatus: undefined | AnnotationDataStatus,
 ): string | undefined {
   if (dataStatus === "absent") {
     return "absent";
@@ -36,7 +37,10 @@ export type ColumnRenderingSpec = {
   fontFamily?: string;
 };
 
-export function getColumnRenderingSpec(spec: PTableColumnSpec): ColumnRenderingSpec {
+export function getColumnRenderingSpec(
+  spec: PTableColumnSpec,
+  dataStatus: undefined | AnnotationDataStatus,
+): ColumnRenderingSpec {
   const valueType = spec.type === "axis" ? spec.spec.type : spec.spec.valueType;
   let renderSpec: ColumnRenderingSpec;
   switch (valueType) {
@@ -45,7 +49,6 @@ export function getColumnRenderingSpec(spec: PTableColumnSpec): ColumnRenderingS
     case ValueType.Float:
     case ValueType.Double: {
       const format = readAnnotation(spec.spec, Annotation.Format);
-      const dataStatus = readAnnotation(spec.spec, Annotation.DataStatus);
       const formatFn = format ? d3.format(format) : undefined;
       renderSpec = {
         valueFormatter: (params) => {
@@ -59,10 +62,7 @@ export function getColumnRenderingSpec(spec: PTableColumnSpec): ColumnRenderingS
     default:
       renderSpec = {
         valueFormatter: (params) => {
-          const formatted = formatSpecialValues(
-            params.value,
-            readAnnotation(spec.spec, Annotation.DataStatus),
-          );
+          const formatted = formatSpecialValues(params.value, dataStatus);
           if (formatted !== undefined) return formatted;
           return params.value?.toString() ?? "";
         },

package/src/components/PlTableFilters/PlTableFiltersV2.vue

@@ -4,16 +4,14 @@ import type {
   PlDataTableFiltersWithMeta,
   PFrameHandle,
   PTableColumnId,
-  CanonicalizedJson,
 } from "@platforma-sdk/model";
 import {
-  canonicalizeJson,
   Annotation,
   Domain,
   readAnnotation,
   readDomain,
   getUniqueSourceValuesWithLabels,
-  parseJson,
+  extractPObjectId,
   getPTableColumnId,
 } from "@platforma-sdk/model";
 import { computed, ref } from "vue";
@@ -68,7 +66,7 @@ const onUpdateFilters = (_value: PlAdvancedFilter) => {
 
 const options = computed<PlAdvancedFilterItem[]>(() => {
   return props.columns.map((col, idx) => {
-    const id = makeFilterColumnId(col);
+    const id = getPTableColumnId(col);
     const label =
       readAnnotation(col.spec, Annotation.Label)?.trim() ?? `Unlabeled ${col.type} ${idx}`;
     const alphabet =
@@ -112,25 +110,23 @@ function handleSuggestOptions(params: {
     return [];
   }
 
-  const strId = params.columnId as CanonicalizedJson<PTableColumnId>;
-  const tableColumnId = parseJson<PTableColumnId>(strId);
-
-  if (tableColumnId.type !== "column") {
+  const tableColumnId = params.columnId as PTableColumnId;
+  if (
+    typeof tableColumnId !== "object" ||
+    tableColumnId === null ||
+    tableColumnId.type !== "column"
+  ) {
     throw new Error("ColumnId should be of type 'column' for suggest options");
   }
 
   return getUniqueSourceValuesWithLabels(props.pframeHandle, {
-    columnId: tableColumnId.id,
+    columnId: extractPObjectId(tableColumnId.id),
     axisIdx: params.axisIdx,
     limit: 100,
     searchQuery: params.searchType === "label" ? params.searchStr : undefined,
     searchQueryValue: params.searchType === "value" ? params.searchStr : undefined,
   }).then((v) => v.values);
 }
-
-function makeFilterColumnId(spec: PTableColumnSpec): CanonicalizedJson<PTableColumnId> {
-  return canonicalizeJson<PTableColumnId>(getPTableColumnId(spec));
-}
 </script>
 
 <template>

package/src/internal/service_factories.ts

@@ -9,6 +9,7 @@
 
 import { Services, UiServiceRegistry } from "@milaboratories/pl-model-common";
 import { SpecDriver } from "@milaboratories/pf-spec-driver";
+import { ColumnsCollectionDriverImpl } from "@milaboratories/columns-collection-driver";
 import type { ServiceProxy } from "@platforma-sdk/model";
 
 export type UiServiceOptions = {
@@ -20,5 +21,6 @@ export function createUiServiceRegistry(options: UiServiceOptions) {
     PFrameSpec: () => new SpecDriver(),
     PFrame: () => options.proxy(Services.PFrame),
     Dialog: () => options.proxy(Services.Dialog),
+    ColumnsCollection: () => new ColumnsCollectionDriverImpl(),
   });
 }