@platforma-sdk/model 1.51.9 → 1.52.3

package/src/pframe_utils/columns.ts

@@ -2,11 +2,11 @@ import type { PColumn, PColumnSpec, PColumnLazy, PFrameDef } from '@milaboratori
 import { getNormalizedAxesList, getAxisId, canonicalizeJson, isLinkerColumn, matchAxisId, isLabelColumn } from '@milaboratories/pl-model-common';
 import type { AxesVault } from '../components';
 import { enrichCompatible, getAvailableWithLinkersAxes } from '../components';
-import type { RenderCtx, PColumnDataUniversal } from '../render';
+import type { RenderCtxBase, PColumnDataUniversal } from '../render';
 import { PColumnCollection } from '../render';
 
 export function getAllRelatedColumns<A, U>(
-  ctx: RenderCtx<A, U>, predicate: (spec: PColumnSpec) => boolean,
+  ctx: RenderCtxBase<A, U>, predicate: (spec: PColumnSpec) => boolean,
 ): PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>> {
   // if current block doesn't produce own columns then use all columns from result pool
   const columns = new PColumnCollection();
@@ -26,7 +26,7 @@ export function getAllRelatedColumns<A, U>(
   return extendedColumns;
 }
 
-export function getRelatedColumns<A, U>(ctx: RenderCtx<A, U>, { columns: rootColumns, predicate }: {
+export function getRelatedColumns<A, U>(ctx: RenderCtxBase<A, U>, { columns: rootColumns, predicate }: {
   columns: PColumn<PColumnDataUniversal>[];
   predicate: (spec: PColumnSpec) => boolean;
 }): PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>> {

package/src/platforma.ts

@@ -1,6 +1,7 @@
 import type { BlockApiV1 } from './block_api_v1';
 import type { BlockApiV2 } from './block_api_v2';
-import type { BlockOutputsBase, BlockState, DriverKit, OutputWithStatus } from '@milaboratories/pl-model-common';
+import type { BlockApiV3 } from './block_api_v3';
+import type { BlockOutputsBase, BlockStateV3, DriverKit, OutputWithStatus } from '@milaboratories/pl-model-common';
 import type { SdkInfo } from './sdk_info';
 import type { BlockStatePatch } from './block_state_patch';
 
@@ -30,12 +31,34 @@ export interface PlatformaV2<
   readonly apiVersion: 2;
 }
 
+export interface PlatformaV3<
+  Args = unknown,
+  Outputs extends Record<string, OutputWithStatus<unknown>> = Record<string, OutputWithStatus<unknown>>,
+  Data = unknown,
+  Href extends `/${string}` = `/${string}`,
+> extends BlockApiV3<Args, Outputs, Data, Href>,
+  DriverKit {
+  /** Information about SDK version current platforma environment was compiled with. */
+  readonly sdkInfo: SdkInfo;
+  readonly apiVersion: 3;
+}
+
 export type Platforma<
   Args = unknown,
   Outputs extends Record<string, OutputWithStatus<unknown>> = Record<string, OutputWithStatus<unknown>>,
   UiState = unknown,
   Href extends `/${string}` = `/${string}`,
-> = PlatformaV1<Args, Outputs, UiState, Href> | PlatformaV2<Args, Outputs, UiState, Href>;
+> = PlatformaV1<Args, Outputs, UiState, Href> | PlatformaV2<Args, Outputs, UiState, Href> | PlatformaV3<Args, Outputs, UiState, Href>;
+
+export type PlatformaExtended<Pl extends Platforma = Platforma> = Pl & {
+  blockModelInfo: BlockModelInfo;
+};
+
+export type BlockModelInfo = {
+  outputs: Record<string, {
+    withStatus: boolean;
+  }>;
+};
 
 export type PlatformaApiVersion = Platforma['apiVersion'];
 
@@ -49,15 +72,18 @@ export type InferUiState<Pl extends Platforma> =
     ? UiState
     : never;
 
+export type InferDataType<Pl extends Platforma> =
+  Pl extends Platforma<unknown, Record<string, OutputWithStatus<unknown>>, infer Data>
+    ? Data
+    : never;
+
 export type InferHrefType<Pl extends Platforma> =
   Pl extends Platforma<unknown, BlockOutputsBase, unknown, infer Href> ? Href : never;
 
 export type PlatformaFactory = (config: { sdkVersion: string }) => Platforma;
 
-export type InferBlockState<Pl extends Platforma> = BlockState<
-  InferArgsType<Pl>,
+export type InferBlockState<Pl extends Platforma> = BlockStateV3<
   InferOutputsType<Pl>,
-  InferUiState<Pl>,
   InferHrefType<Pl>
 >;
 

package/src/render/api.ts

@@ -515,33 +515,22 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
 }
 
 /** Main entry point to the API available within model lambdas (like outputs, sections, etc..) */
-export class RenderCtx<Args, UiState> {
-  private readonly ctx: GlobalCfgRenderCtx;
+export abstract class RenderCtxBase<Args, Data> {
+  protected readonly ctx: GlobalCfgRenderCtx;
 
   constructor() {
     this.ctx = getCfgRenderCtx();
   }
 
-  private _argsCache?: { v: Args };
-
-  public get args(): Args {
-    if (this._argsCache === undefined) {
-      const raw = this.ctx.args;
-      const value = typeof raw === 'function' ? raw() : raw;
-      this._argsCache = { v: JSON.parse(value) };
-    }
-    return this._argsCache.v;
-  }
-
-  private _uiStateCache?: { v: UiState };
+  private _dataCache?: { v: Data };
 
-  public get uiState(): UiState {
-    if (this._uiStateCache === undefined) {
-      const raw = this.ctx.uiState;
+  public get data(): Data {
+    if (this._dataCache === undefined) {
+      const raw = this.ctx.data;
       const value = typeof raw === 'function' ? raw() : raw;
-      this._uiStateCache = { v: value ? JSON.parse(value) : ({} as UiState) };
+      this._dataCache = { v: value ? JSON.parse(value) : ({} as Data) };
     }
-    return this._uiStateCache.v;
+    return this._dataCache.v;
   }
 
   // lazy rendering because this feature is rarely used
@@ -691,8 +680,50 @@ export class RenderCtx<Args, UiState> {
   }
 }
 
-export type RenderFunction<Args = unknown, UiState = unknown, Ret = unknown> = (
-  rCtx: RenderCtx<Args, UiState>
+/** Main entry point to the API available within model lambdas (like outputs, sections, etc..) for v3+ blocks */
+export class RenderCtx<Args, Data> extends RenderCtxBase<Args, Data> {
+  private _argsCache?: { v: Args | undefined };
+  public get args(): Args | undefined {
+    if (this._argsCache === undefined) {
+      const raw = this.ctx.args;
+      const value = typeof raw === 'function' ? raw() : raw;
+      // args can be undefined when derivation fails (e.g., validation error in args())
+      this._argsCache = { v: value === undefined ? undefined : JSON.parse(value) };
+    }
+    return this._argsCache.v;
+  }
+}
+
+/** Render context for legacy v1/v2 blocks - provides backward compatibility */
+export class RenderCtxLegacy<Args, UiState> extends RenderCtxBase<Args, UiState> {
+  private _argsCache?: { v: Args };
+  public get args(): Args {
+    if (this._argsCache === undefined) {
+      const raw = this.ctx.args;
+      const value = typeof raw === 'function' ? raw() : raw;
+      this._argsCache = { v: JSON.parse(value) };
+    }
+    return this._argsCache.v;
+  }
+
+  private _uiStateCache?: { v: UiState };
+
+  public get uiState(): UiState {
+    if (this._uiStateCache === undefined) {
+      const raw = this.ctx.uiState!;
+      const value = typeof raw === 'function' ? raw() : raw;
+      this._uiStateCache = { v: value ? JSON.parse(value) : ({} as UiState) };
+    }
+    return this._uiStateCache.v;
+  }
+}
+
+export type RenderFunction<Args = unknown, State = unknown, Ret = unknown> = (
+  rCtx: RenderCtx<Args, State>
+) => Ret;
+
+export type RenderFunctionLegacy<Args = unknown, State = unknown, Ret = unknown> = (
+  rCtx: RenderCtxLegacy<Args, State>
 ) => Ret;
 
 export type UnwrapFutureRef<K> =

package/src/render/internal.ts

@@ -183,7 +183,9 @@ export interface GlobalCfgRenderCtx extends GlobalCfgRenderCtxMethods {
   //
 
   readonly args: string | (() => string);
-  readonly uiState: string | (() => string);
+  /** @deprecated Use `data` instead. Optional for backward compatibility - falls back to `data` if not injected. */
+  readonly uiState?: string | (() => string);
+  readonly data: string | (() => string);
   readonly activeArgs: undefined | string | (() => string | undefined);
 
   // Note: strings below are used because, anyway, using strings is the only way