@platforma-sdk/model 1.81.1 → 1.83.0

package/src/template_params.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, expectTypeOf, test } from "vitest";
+import type { PlRef } from "@milaboratories/pl-model-common";
+import { createPlRef, stringifyJson } from "@milaboratories/pl-model-common";
+import { createBlockStorage } from "./block_storage";
+import { deriveTemplateParamsFromStorage } from "./block_storage_callbacks";
+import { BlockModelV3 } from "./block_model";
+import { DataModelBuilder } from "./block_migrations";
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+
+// A kind whose params carry a reference — the case that exercises the rewrite.
+type Params = { sources?: PlRef[]; label: string };
+
+const kind = defineBlockKind<Params>({
+  name: "@platforma-open/milaboratories.demo.kind",
+  version: "1.0.0",
+  // These tests are about the export direction, so the parser only carries the shape
+  // through; rejection behaviour lives in `template_init.test.ts`.
+  parseInitializationParams: (value) => value as Params,
+});
+
+type BlockData = { sources: PlRef[]; label: string; scratch: number };
+
+const dataModel = new DataModelBuilder({ kind }).from<BlockData>("v1").init(({ params }) => ({
+  sources: params?.sources ?? [],
+  label: params?.label ?? "",
+  // Derived/runtime state — must NOT survive into a template entry.
+  scratch: 0,
+}));
+
+const upstream = "3f1c2b7a-0000-4000-8000-000000000001";
+
+const storageOf = (data: BlockData) => stringifyJson(createBlockStorage(data));
+
+describe("deriveTemplateParamsFromStorage", () => {
+  test("projects data back to params, untouched", () => {
+    const result = deriveTemplateParamsFromStorage(
+      storageOf({ sources: [createPlRef(upstream, "reads")], label: "run 1", scratch: 42 }),
+      (data) => {
+        const d = data as BlockData;
+        return { sources: d.sources, label: d.label };
+      },
+    );
+
+    // `scratch` is dropped because the lambda does not return it. Everything the lambda DID
+    // return is written exactly as it is: the reference is not marked, normalized or rewritten
+    // on the way out, because pointing it at another project is the receiving block's job, on
+    // the way back in.
+    expect(result).toEqual({
+      value: { sources: [createPlRef(upstream, "reads")], label: "run 1" },
+    });
+  });
+
+  test("a block with nothing to project yields empty params, not absent ones", () => {
+    // Every block declares the lambda, so there is no "no params" outcome to test for.
+    // A block whose state carries nothing worth restoring returns `{}`, and `{}` is what
+    // gets written — the entry is still checked against the kind on the way back in.
+    expect(
+      deriveTemplateParamsFromStorage(
+        storageOf({ sources: [], label: "", scratch: 0 }),
+        () => ({}),
+      ),
+    ).toEqual({ value: {} });
+  });
+
+  test("a throwing lambda is reported, not propagated", () => {
+    const result = deriveTemplateParamsFromStorage(
+      storageOf({ sources: [], label: "", scratch: 0 }),
+      () => {
+        throw new Error("not exportable yet");
+      },
+    );
+
+    expect(result).toEqual({ error: "templateParams() threw: not exportable yet" });
+  });
+});
+
+describe("BlockModelV3.templateParams", () => {
+  test("the lambda's return type is the kind's params", () => {
+    const model = BlockModelV3.create({ dataModel, kind })
+      .args((data) => ({ label: data.label }))
+      .templateParams((data) => ({ sources: data.sources, label: data.label }));
+
+    expectTypeOf(model.templateParams).parameter(0).toEqualTypeOf<(data: BlockData) => Params>();
+  });
+
+  test("a projection that drifts from the kind's params does not compile", () => {
+    const builder = BlockModelV3.create({ dataModel, kind }).args((data) => ({
+      label: data.label,
+    }));
+
+    // @ts-expect-error - `label` is required by Params
+    builder.templateParams((data) => ({ sources: data.sources }));
+    // @ts-expect-error - wrong type for a declared param
+    builder.templateParams(() => ({ label: 42 }));
+  });
+
+  test("KNOWN HOLE: an extra field the kind does not declare is not rejected", () => {
+    const builder = BlockModelV3.create({ dataModel, kind }).args((data) => ({
+      label: data.label,
+    }));
+
+    // No `@ts-expect-error` here, and that is the point: TypeScript does not
+    // apply excess-property checks to an object literal returned from a
+    // contextually-typed arrow, so `scratch` type-checks and would be written
+    // into the exported file. The kind's parser does not catch it either — that runs
+    // on params coming IN, and nothing runs on what the projection hands back. The
+    // asymmetry is real: such a file is written happily and rejected on re-import by
+    // the same kind that would have caught it here. This test pins current behaviour.
+    builder.templateParams((data) => ({
+      label: data.label,
+      sources: data.sources,
+      scratch: data.scratch,
+    }));
+  });
+
+  test("a model that declares it builds", () => {
+    expect(() =>
+      BlockModelV3.create({ dataModel, kind })
+        .args((data) => ({ label: data.label }))
+        .templateParams((data) => ({ sources: data.sources, label: data.label }))
+        .done(),
+    ).not.toThrow();
+  });
+
+  test("a model that omits it does not build", () => {
+    // The projection is not optional. Without this gate a block exports an entry with
+    // no params, which applies as a default-initialized block that looks restored — so
+    // the failure has to land on whoever wrote the model, at build.
+    expect(() =>
+      BlockModelV3.create({ dataModel, kind })
+        .args((data) => ({ label: data.label }))
+        .done(),
+    ).toThrow(/templateParams\(\) not set/);
+  });
+});

package/src/typing.test.ts

@@ -1,34 +1,6 @@
-import {
-  BlockSection,
-  LocalBlobHandleAndSize,
-  OutputWithStatus,
-  RemoteBlobHandleAndSize,
-} from "@milaboratories/pl-model-common";
-import { expect, test } from "vitest";
-import { DeriveHref, StdCtx } from "./bconfig";
-import { BlockModel } from "./block_model_legacy";
-import {
-  Args,
-  ConfigResult,
-  flatten,
-  getBlobContent,
-  getBlobContentAsJson,
-  getBlobContentAsString,
-  getDownloadedBlobContent,
-  getImmediate,
-  getJsonField,
-  getOnDemandBlobContent,
-  getResourceField,
-  getResourceValueAsJson,
-  isEmpty,
-  It,
-  MainOutputs,
-  makeArray,
-  makeObject,
-  mapArrayValues,
-  mapRecordValues,
-} from "./config";
-import { InferHrefType, InferOutputsType } from "./platforma";
+import { BlockSection } from "@milaboratories/pl-model-common";
+import { test } from "vitest";
+import { DeriveHref } from "./bconfig";
 
 type AssertEqual<T, Expected> = [T] extends [Expected]
   ? [Expected] extends [T]
@@ -50,43 +22,11 @@ export const assertTypeExtends = <T, Expected>(
   // noop
 };
 
-function _typeTest1() {
-  const a = getJsonField(Args, "field1");
-  const dd = getResourceValueAsJson<{ s: boolean; g: number }>()(
-    getResourceField(MainOutputs, "a"),
-  );
-
-  const cfg1 = makeObject({
-    a,
-    b: "attagaca",
-    c: mapRecordValues(getJsonField(Args, "field2"), getJsonField(It, "b")),
-    d: getJsonField(dd, "s"),
-  });
-
-  type Ret = ConfigResult<
-    typeof cfg1,
-    StdCtx<{
-      field1: number;
-      field2: Record<string, { b: "yap" }>;
-    }>
-  >;
-
-  assertType<
-    Ret,
-    {
-      a: number;
-      b: "attagaca";
-      c: Record<string, "yap">;
-      d: boolean;
-    }
-  >();
-}
-
 function testCreateSections<const S extends BlockSection[]>(_sections: () => S): DeriveHref<S> {
   return undefined as any;
 }
 
-test("test config content", () => {
+test("href derivation from sections", () => {
   const s1 = testCreateSections(() => [
     { type: "delimiter" },
     { type: "link", href: "/a1", label: "l" },
@@ -99,82 +39,3 @@ test("test config content", () => {
 
   assertType<typeof s2, never>();
 });
-
-test("test config content", () => {
-  const platforma = BlockModel.create("Heavy")
-    .withArgs<{ a: string[] }>({ a: [] })
-    .argsValid(isEmpty(getJsonField(Args, "a")))
-    .output("cell1", makeObject({ b: getJsonField(Args, "a") }))
-    .output("cell2", mapArrayValues(getJsonField(Args, "a"), getImmediate("v1")))
-    .sections(() => {
-      return [
-        { type: "link", href: "/", label: "Main" },
-        { type: "link", href: "/subsection", label: "Subsection" },
-      ];
-    })
-    .done();
-
-  assertType<
-    InferOutputsType<typeof platforma>,
-    {
-      cell1: OutputWithStatus<{ b: string[] }>;
-      cell2: OutputWithStatus<"v1"[]>;
-    }
-  >();
-
-  assertType<InferHrefType<typeof platforma>, "/" | "/subsection">();
-
-  expect(JSON.stringify((platforma as any).config).length).toBeGreaterThan(20);
-});
-
-test("test config 2", () => {
-  const platforma = BlockModel.create<{ a: string[] }>("Heavy")
-    .initialArgs({ a: [] })
-    .output(
-      "cell1",
-      makeObject({
-        b: getBlobContentAsString(getResourceField(MainOutputs, "field1")),
-        c: makeArray(getBlobContent(getResourceField(MainOutputs, "field2")), "asd"),
-        d: getBlobContentAsJson<string[]>()(getResourceField(MainOutputs, "field3")),
-        e: flatten(
-          makeArray(
-            getBlobContentAsJson<string[]>()(getResourceField(MainOutputs, "field3")),
-            getImmediate(["asd", "d"] as string[]),
-          ),
-        ),
-        f: getDownloadedBlobContent(getResourceField(MainOutputs, "field4")),
-        g: getOnDemandBlobContent(getResourceField(MainOutputs, "field5")),
-      }),
-    )
-    .output("cell2", () => 42)
-    .output("cell3", () => undefined)
-    .withArgs(isEmpty(getJsonField(Args, "a")))
-    .sections(
-      () =>
-        [
-          { type: "link", href: "/", label: "Main" },
-          { type: "link", href: "/subsection", label: "Subsection" },
-        ] satisfies BlockSection[],
-    )
-    .done();
-
-  assertType<
-    InferOutputsType<typeof platforma>,
-    {
-      cell1: OutputWithStatus<{
-        b: string;
-        c: [Uint8Array, "asd"];
-        d: string[];
-        e: string[];
-        f: LocalBlobHandleAndSize;
-        g: RemoteBlobHandleAndSize;
-      }>;
-      cell2: OutputWithStatus<number>;
-      cell3: OutputWithStatus<undefined>;
-    }
-  >();
-
-  assertType<InferHrefType<typeof platforma>, "/" | "/subsection">();
-
-  expect(JSON.stringify((platforma as any).config).length).toBeGreaterThan(20);
-});

package/dist/block_model_legacy.cjs

@@ -1,240 +0,0 @@
-const require_internal = require("./internal.cjs");
-const require_actions = require("./config/actions.cjs");
-require("./config/index.cjs");
-const require_api = require("./render/api.cjs");
-require("./render/index.cjs");
-const require_version = require("./version.cjs");
-const require_types = require("./bconfig/types.cjs");
-const require_normalization = require("./bconfig/normalization.cjs");
-require("./bconfig/index.cjs");
-let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
-//#region src/block_model_legacy.ts
-/** Main entry point that each block should use in it's "config" module. Don't forget
-* to call {@link done()} at the end of configuration. Value returned by this builder must be
-* exported as constant with name "platforma" from the "config" module. */
-var BlockModel = class BlockModel {
-	config;
-	constructor(config) {
-		this.config = config;
-	}
-	static get INITIAL_BLOCK_FEATURE_FLAGS() {
-		return {
-			supportsLazyState: true,
-			supportsPframeQueryRanking: true,
-			requiresUIAPIVersion: 1,
-			requiresModelAPIVersion: 1,
-			requiresCreatePTable: 2,
-			requiresPFramesVersion: _milaboratories_pl_model_common.REQUIRES_PFRAMES_VERSION
-		};
-	}
-	static create(renderingMode = "Heavy") {
-		return new BlockModel({
-			renderingMode,
-			initialUiState: {},
-			outputs: {},
-			inputsValid: require_actions.getImmediate(true),
-			sections: require_actions.getImmediate([]),
-			featureFlags: BlockModel.INITIAL_BLOCK_FEATURE_FLAGS
-		});
-	}
-	output(key, cfgOrRf, flags = {}) {
-		if (typeof cfgOrRf === "function") {
-			const handle = `output#${key}`;
-			require_internal.tryRegisterCallback(handle, () => cfgOrRf(new require_api.RenderCtxLegacy()));
-			return new BlockModel({
-				...this.config,
-				outputs: {
-					...this.config.outputs,
-					[key]: {
-						__renderLambda: true,
-						handle,
-						...flags
-					}
-				}
-			});
-		} else return new BlockModel({
-			...this.config,
-			outputs: {
-				...this.config.outputs,
-				[key]: cfgOrRf
-			}
-		});
-	}
-	/** Shortcut for {@link output} with retentive flag set to true. */
-	retentiveOutput(key, rf) {
-		return this.output(key, rf, { retentive: true });
-	}
-	/** Shortcut for {@link output} with withStatus flag set to true. */
-	outputWithStatus(key, rf) {
-		return this.output(key, rf, { withStatus: true });
-	}
-	/** Shortcut for {@link output} with retentive and withStatus flags set to true. */
-	retentiveOutputWithStatus(key, rf) {
-		return this.output(key, rf, {
-			retentive: true,
-			withStatus: true
-		});
-	}
-	argsValid(cfgOrRf) {
-		if (typeof cfgOrRf === "function") {
-			require_internal.tryRegisterCallback("inputsValid", () => cfgOrRf(new require_api.RenderCtxLegacy()));
-			return new BlockModel({
-				...this.config,
-				inputsValid: {
-					__renderLambda: true,
-					handle: "inputsValid"
-				}
-			});
-		} else return new BlockModel({
-			...this.config,
-			inputsValid: cfgOrRf
-		});
-	}
-	sections(arrOrCfgOrRf) {
-		if (Array.isArray(arrOrCfgOrRf)) return this.sections(require_actions.getImmediate(arrOrCfgOrRf));
-		else if (typeof arrOrCfgOrRf === "function") {
-			require_internal.tryRegisterCallback("sections", () => arrOrCfgOrRf(new require_api.RenderCtxLegacy()));
-			return new BlockModel({
-				...this.config,
-				sections: {
-					__renderLambda: true,
-					handle: "sections"
-				}
-			});
-		} else return new BlockModel({
-			...this.config,
-			sections: arrOrCfgOrRf
-		});
-	}
-	/** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
-	title(rf) {
-		require_internal.tryRegisterCallback("title", () => rf(new require_api.RenderCtxLegacy()));
-		return new BlockModel({
-			...this.config,
-			title: {
-				__renderLambda: true,
-				handle: "title"
-			}
-		});
-	}
-	subtitle(rf) {
-		require_internal.tryRegisterCallback("subtitle", () => rf(new require_api.RenderCtxLegacy()));
-		return new BlockModel({
-			...this.config,
-			subtitle: {
-				__renderLambda: true,
-				handle: "subtitle"
-			}
-		});
-	}
-	tags(rf) {
-		require_internal.tryRegisterCallback("tags", () => rf(new require_api.RenderCtxLegacy()));
-		return new BlockModel({
-			...this.config,
-			tags: {
-				__renderLambda: true,
-				handle: "tags"
-			}
-		});
-	}
-	/**
-	* Sets initial args for the block, this value must be specified.
-	* @deprecated use {@link withArgs}
-	* */
-	initialArgs(value) {
-		return this.withArgs(value);
-	}
-	/** Sets initial args for the block, this value must be specified. */
-	withArgs(initialArgs) {
-		return new BlockModel({
-			...this.config,
-			initialArgs
-		});
-	}
-	/** Defines type and sets initial value for block UiState. */
-	withUiState(initialUiState) {
-		return new BlockModel({
-			...this.config,
-			initialUiState
-		});
-	}
-	/** Sets or overrides feature flags for the block. */
-	withFeatureFlags(flags) {
-		return new BlockModel({
-			...this.config,
-			featureFlags: {
-				...this.config.featureFlags,
-				...flags
-			}
-		});
-	}
-	/**
-	* Defines how to derive list of upstream references this block is meant to enrich with its exports from block args.
-	* Influences dependency graph construction.
-	*/
-	enriches(lambda) {
-		require_internal.tryRegisterCallback("enrichmentTargets", lambda);
-		return new BlockModel({
-			...this.config,
-			enrichmentTargets: {
-				__renderLambda: true,
-				handle: "enrichmentTargets"
-			}
-		});
-	}
-	/** Renders all provided block settings into a pre-configured platforma API
-	* instance, that can be used in frontend to interact with block state, and
-	* other features provided by the platforma to the block. */
-	done(apiVersion = 1) {
-		return this.withFeatureFlags({
-			...this.config.featureFlags,
-			requiresUIAPIVersion: apiVersion
-		}).#done();
-	}
-	#done() {
-		if (this.config.initialArgs === void 0) throw new Error("Initial arguments not set.");
-		const config = {
-			v4: void 0,
-			v3: {
-				configVersion: 3,
-				modelAPIVersion: 1,
-				sdkVersion: require_version.PlatformaSDKVersion,
-				renderingMode: this.config.renderingMode,
-				initialArgs: this.config.initialArgs,
-				initialUiState: this.config.initialUiState,
-				inputsValid: this.config.inputsValid,
-				sections: this.config.sections,
-				title: this.config.title,
-				subtitle: this.config.subtitle,
-				tags: this.config.tags,
-				outputs: this.config.outputs,
-				enrichmentTargets: this.config.enrichmentTargets,
-				featureFlags: this.config.featureFlags
-			},
-			sdkVersion: require_version.PlatformaSDKVersion,
-			renderingMode: this.config.renderingMode,
-			initialArgs: this.config.initialArgs,
-			inputsValid: require_normalization.downgradeCfgOrLambda(this.config.inputsValid),
-			sections: require_normalization.downgradeCfgOrLambda(this.config.sections),
-			outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [key, require_normalization.downgradeCfgOrLambda(value)]))
-		};
-		globalThis.platformaApiVersion = this.config.featureFlags.requiresUIAPIVersion;
-		if (!require_internal.isInUI()) return { config };
-		else return {
-			...require_internal.getPlatformaInstance({
-				sdkVersion: require_version.PlatformaSDKVersion,
-				apiVersion: platformaApiVersion
-			}),
-			blockModelInfo: {
-				outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [key, { withStatus: Boolean(require_types.isConfigLambda(value) && value.withStatus) }])),
-				pluginIds: [],
-				featureFlags: this.config.featureFlags,
-				pluginPublicOutputs: {}
-			}
-		};
-	}
-};
-//#endregion
-exports.BlockModel = BlockModel;
-
-//# sourceMappingURL=block_model_legacy.cjs.map

package/dist/block_model_legacy.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"block_model_legacy.cjs","names":["REQUIRES_PFRAMES_VERSION","getImmediate","RenderCtxLegacy","#done","PlatformaSDKVersion","downgradeCfgOrLambda","isInUI","getPlatformaInstance","isConfigLambda"],"sources":["../src/block_model_legacy.ts"],"sourcesContent":["import type {\n  BlockRenderingMode,\n  BlockSection,\n  AnyFunction,\n  PlRef,\n  BlockCodeKnownFeatureFlags,\n  BlockConfigContainer,\n} from \"@milaboratories/pl-model-common\";\nimport { REQUIRES_PFRAMES_VERSION } from \"@milaboratories/pl-model-common\";\nimport type { Checked, ConfigResult, TypedConfig } from \"./config\";\nimport { getImmediate } from \"./config\";\nimport { getPlatformaInstance, isInUI, tryRegisterCallback } from \"./internal\";\nimport type { Platforma, PlatformaApiVersion, PlatformaV1, PlatformaV2 } from \"./platforma\";\nimport type { InferRenderFunctionReturn, RenderFunctionLegacy } from \"./render\";\nimport { RenderCtxLegacy } from \"./render\";\nimport { PlatformaSDKVersion } from \"./version\";\nimport type {\n  TypedConfigOrConfigLambda,\n  ConfigRenderLambda,\n  StdCtxArgsOnly,\n  DeriveHref,\n  ConfigRenderLambdaFlags,\n  InferOutputsFromConfigs,\n} from \"./bconfig\";\nimport { downgradeCfgOrLambda, isConfigLambda } from \"./bconfig\";\nimport type { PlatformaExtended } from \"./platforma\";\n\ntype SectionsExpectedType = readonly BlockSection[];\n\ntype SectionsCfgChecked<Cfg extends TypedConfig, Args, UiState> = Checked<\n  Cfg,\n  ConfigResult<Cfg, StdCtxArgsOnly<Args, UiState>> extends SectionsExpectedType ? true : false\n>;\n\ntype InputsValidExpectedType = boolean;\n\ntype InputsValidCfgChecked<Cfg extends TypedConfig, Args, UiState> = Checked<\n  Cfg,\n  ConfigResult<Cfg, StdCtxArgsOnly<Args, UiState>> extends InputsValidExpectedType ? true : false\n>;\n\ntype NoOb = Record<string, never>;\n\n/** Main entry point that each block should use in it's \"config\" module. Don't forget\n * to call {@link done()} at the end of configuration. Value returned by this builder must be\n * exported as constant with name \"platforma\" from the \"config\" module. */\nexport class BlockModel<\n  Args,\n  OutputsCfg extends Record<string, TypedConfigOrConfigLambda>,\n  UiState,\n  Href extends `/${string}` = \"/\",\n> {\n  private constructor(\n    private config: {\n      readonly renderingMode: BlockRenderingMode;\n      readonly initialArgs?: Args;\n      readonly initialUiState: UiState;\n      readonly outputs: OutputsCfg;\n      readonly inputsValid: TypedConfigOrConfigLambda;\n      readonly sections: TypedConfigOrConfigLambda;\n      readonly title?: ConfigRenderLambda;\n      readonly subtitle?: ConfigRenderLambda;\n      readonly tags?: ConfigRenderLambda;\n      readonly enrichmentTargets?: ConfigRenderLambda;\n      readonly featureFlags: BlockCodeKnownFeatureFlags;\n    },\n  ) {}\n\n  public static get INITIAL_BLOCK_FEATURE_FLAGS(): BlockCodeKnownFeatureFlags {\n    return {\n      supportsLazyState: true,\n      supportsPframeQueryRanking: true,\n      requiresUIAPIVersion: 1,\n      requiresModelAPIVersion: 1,\n      requiresCreatePTable: 2,\n      requiresPFramesVersion: REQUIRES_PFRAMES_VERSION,\n    };\n  }\n\n  /** Initiates configuration builder */\n  public static create(renderingMode: BlockRenderingMode): BlockModel<NoOb, {}, NoOb>;\n  /** Initiates configuration builder */\n  public static create(): BlockModel<NoOb, {}, NoOb>;\n  /**\n   * Initiates configuration builder\n   * @deprecated use create method without generic parameter\n   */\n  public static create<Args>(renderingMode: BlockRenderingMode): BlockModel<Args, {}, NoOb>;\n  /**\n   * Initiates configuration builder\n   * @deprecated use create method without generic parameter\n   */\n  public static create<Args>(): BlockModel<Args, {}, NoOb>;\n  public static create(renderingMode: BlockRenderingMode = \"Heavy\"): BlockModel<NoOb, {}, NoOb> {\n    return new BlockModel<NoOb, {}, NoOb>({\n      renderingMode,\n      initialUiState: {},\n      outputs: {},\n      inputsValid: getImmediate(true),\n      sections: getImmediate([]),\n      featureFlags: BlockModel.INITIAL_BLOCK_FEATURE_FLAGS,\n    });\n  }\n\n  /**\n   * Add output cell to the configuration\n   *\n   * @param key output cell name, that can be later used to retrieve the rendered value\n   * @param cfg configuration describing how to render cell value from the blocks\n   *            workflow outputs\n   * @deprecated use lambda-based API\n   * */\n  public output<const Key extends string, const Cfg extends TypedConfig>(\n    key: Key,\n    cfg: Cfg,\n  ): BlockModel<Args, OutputsCfg & { [K in Key]: Cfg }, UiState, Href>;\n  /**\n   * Add output cell wrapped with additional status information to the configuration\n   *\n   * @param key output cell name, that can be later used to retrieve the rendered value\n   * @param rf  callback calculating output value using context, that allows to access\n   *            workflows outputs and interact with platforma drivers\n   * @param flags additional flags that may alter lambda rendering procedure\n   * */\n  public output<const Key extends string, const RF extends RenderFunctionLegacy<Args, UiState>>(\n    key: Key,\n    rf: RF,\n    flags: ConfigRenderLambdaFlags & { withStatus: true },\n  ): BlockModel<\n    Args,\n    OutputsCfg & {\n      [K in Key]: ConfigRenderLambda<InferRenderFunctionReturn<RF>> & { withStatus: true };\n    },\n    UiState,\n    Href\n  >;\n  /**\n   * Add output cell to the configuration\n   *\n   * @param key output cell name, that can be later used to retrieve the rendered value\n   * @param rf  callback calculating output value using context, that allows to access\n   *            workflows outputs and interact with platforma drivers\n   * @param flags additional flags that may alter lambda rendering procedure\n   * */\n  public output<const Key extends string, const RF extends RenderFunctionLegacy<Args, UiState>>(\n    key: Key,\n    rf: RF,\n    flags?: ConfigRenderLambdaFlags,\n  ): BlockModel<\n    Args,\n    OutputsCfg & { [K in Key]: ConfigRenderLambda<InferRenderFunctionReturn<RF>> },\n    UiState,\n    Href\n  >;\n  public output(\n    key: string,\n    cfgOrRf: TypedConfig | AnyFunction,\n    flags: ConfigRenderLambdaFlags = {},\n  ): BlockModel<Args, OutputsCfg, UiState, Href> {\n    if (typeof cfgOrRf === \"function\") {\n      const handle = `output#${key}`;\n      tryRegisterCallback(handle, () => cfgOrRf(new RenderCtxLegacy()));\n      return new BlockModel({\n        ...this.config,\n        outputs: {\n          ...this.config.outputs,\n          [key]: {\n            __renderLambda: true,\n            handle,\n            ...flags,\n          },\n        },\n      });\n    } else {\n      return new BlockModel({\n        ...this.config,\n        outputs: {\n          ...this.config.outputs,\n          [key]: cfgOrRf,\n        },\n      });\n    }\n  }\n\n  /** Shortcut for {@link output} with retentive flag set to true. */\n  public retentiveOutput<\n    const Key extends string,\n    const RF extends RenderFunctionLegacy<Args, UiState>,\n  >(key: Key, rf: RF) {\n    return this.output(key, rf, { retentive: true });\n  }\n\n  /** Shortcut for {@link output} with withStatus flag set to true. */\n  public outputWithStatus<\n    const Key extends string,\n    const RF extends RenderFunctionLegacy<Args, UiState>,\n  >(key: Key, rf: RF) {\n    return this.output(key, rf, { withStatus: true });\n  }\n\n  /** Shortcut for {@link output} with retentive and withStatus flags set to true. */\n  public retentiveOutputWithStatus<\n    const Key extends string,\n    const RF extends RenderFunctionLegacy<Args, UiState>,\n  >(key: Key, rf: RF) {\n    return this.output(key, rf, { retentive: true, withStatus: true });\n  }\n\n  /** Sets custom configuration predicate on the block args at which block can be executed\n   * @deprecated use lambda-based API */\n  public argsValid<Cfg extends TypedConfig>(\n    cfg: Cfg & InputsValidCfgChecked<Cfg, Args, UiState>,\n  ): BlockModel<Args, OutputsCfg, UiState, Href>;\n  /** Sets custom configuration predicate on the block args at which block can be executed */\n  public argsValid<RF extends RenderFunctionLegacy<Args, UiState, boolean>>(\n    rf: RF,\n  ): BlockModel<Args, OutputsCfg, UiState, Href>;\n  public argsValid(\n    cfgOrRf: TypedConfig | AnyFunction,\n  ): BlockModel<Args, OutputsCfg, UiState, `/${string}`> {\n    if (typeof cfgOrRf === \"function\") {\n      tryRegisterCallback(\"inputsValid\", () => cfgOrRf(new RenderCtxLegacy()));\n      return new BlockModel<Args, OutputsCfg, UiState>({\n        ...this.config,\n        inputsValid: {\n          __renderLambda: true,\n          handle: \"inputsValid\",\n        },\n      });\n    } else {\n      return new BlockModel<Args, OutputsCfg, UiState>({\n        ...this.config,\n        inputsValid: cfgOrRf,\n      });\n    }\n  }\n\n  /** Sets the config to generate list of section in the left block overviews panel\n   * @deprecated use lambda-based API */\n  public sections<const S extends SectionsExpectedType>(\n    rf: S,\n  ): BlockModel<Args, OutputsCfg, UiState, DeriveHref<S>>;\n  /** Sets the config to generate list of section in the left block overviews panel */\n  public sections<\n    const Ret extends SectionsExpectedType,\n    const RF extends RenderFunctionLegacy<Args, UiState, Ret>,\n  >(rf: RF): BlockModel<Args, OutputsCfg, UiState, DeriveHref<ReturnType<RF>>>;\n  public sections<const Cfg extends TypedConfig>(\n    cfg: Cfg & SectionsCfgChecked<Cfg, Args, UiState>,\n  ): BlockModel<\n    Args,\n    OutputsCfg,\n    UiState,\n    DeriveHref<ConfigResult<Cfg, StdCtxArgsOnly<Args, UiState>>>\n  >;\n  public sections(\n    arrOrCfgOrRf: SectionsExpectedType | TypedConfig | AnyFunction,\n  ): BlockModel<Args, OutputsCfg, UiState, `/${string}`> {\n    if (Array.isArray(arrOrCfgOrRf)) {\n      return this.sections(getImmediate(arrOrCfgOrRf));\n    } else if (typeof arrOrCfgOrRf === \"function\") {\n      tryRegisterCallback(\"sections\", () => arrOrCfgOrRf(new RenderCtxLegacy()));\n      return new BlockModel<Args, OutputsCfg, UiState>({\n        ...this.config,\n        sections: {\n          __renderLambda: true,\n          handle: \"sections\",\n        },\n      });\n    } else {\n      return new BlockModel<Args, OutputsCfg, UiState>({\n        ...this.config,\n        sections: arrOrCfgOrRf as TypedConfig,\n      });\n    }\n  }\n\n  /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */\n  public title(\n    rf: RenderFunctionLegacy<Args, UiState, string>,\n  ): BlockModel<Args, OutputsCfg, UiState, Href> {\n    tryRegisterCallback(\"title\", () => rf(new RenderCtxLegacy()));\n    return new BlockModel<Args, OutputsCfg, UiState, Href>({\n      ...this.config,\n      title: {\n        __renderLambda: true,\n        handle: \"title\",\n      },\n    });\n  }\n\n  public subtitle(\n    rf: RenderFunctionLegacy<Args, UiState, string>,\n  ): BlockModel<Args, OutputsCfg, UiState, Href> {\n    tryRegisterCallback(\"subtitle\", () => rf(new RenderCtxLegacy()));\n    return new BlockModel<Args, OutputsCfg, UiState, Href>({\n      ...this.config,\n      subtitle: {\n        __renderLambda: true,\n        handle: \"subtitle\",\n      },\n    });\n  }\n\n  public tags(\n    rf: RenderFunctionLegacy<Args, UiState, string[]>,\n  ): BlockModel<Args, OutputsCfg, UiState, Href> {\n    tryRegisterCallback(\"tags\", () => rf(new RenderCtxLegacy()));\n    return new BlockModel<Args, OutputsCfg, UiState, Href>({\n      ...this.config,\n      tags: {\n        __renderLambda: true,\n        handle: \"tags\",\n      },\n    });\n  }\n\n  /**\n   * Sets initial args for the block, this value must be specified.\n   * @deprecated use {@link withArgs}\n   * */\n  public initialArgs(value: Args): BlockModel<Args, OutputsCfg, UiState, Href> {\n    return this.withArgs(value);\n  }\n\n  /** Sets initial args for the block, this value must be specified. */\n  public withArgs<Args>(initialArgs: Args): BlockModel<Args, OutputsCfg, UiState, Href> {\n    return new BlockModel<Args, OutputsCfg, UiState, Href>({\n      ...this.config,\n      initialArgs,\n    });\n  }\n\n  /** Defines type and sets initial value for block UiState. */\n  public withUiState<UiState>(\n    initialUiState: UiState,\n  ): BlockModel<Args, OutputsCfg, UiState, Href> {\n    return new BlockModel<Args, OutputsCfg, UiState, Href>({\n      ...this.config,\n      initialUiState,\n    });\n  }\n\n  /** Sets or overrides feature flags for the block. */\n  public withFeatureFlags(\n    flags: Partial<BlockCodeKnownFeatureFlags>,\n  ): BlockModel<Args, OutputsCfg, UiState, Href> {\n    return new BlockModel<Args, OutputsCfg, UiState, Href>({\n      ...this.config,\n      featureFlags: {\n        ...this.config.featureFlags,\n        ...flags,\n      },\n    });\n  }\n\n  /**\n   * Defines how to derive list of upstream references this block is meant to enrich with its exports from block args.\n   * Influences dependency graph construction.\n   */\n  public enriches(lambda: (args: Args) => PlRef[]): BlockModel<Args, OutputsCfg, UiState, Href> {\n    tryRegisterCallback(\"enrichmentTargets\", lambda);\n    return new BlockModel<Args, OutputsCfg, UiState, Href>({\n      ...this.config,\n      enrichmentTargets: {\n        __renderLambda: true,\n        handle: \"enrichmentTargets\",\n      },\n    });\n  }\n\n  public done(\n    apiVersion?: 1,\n  ): PlatformaExtended<\n    PlatformaV1<Args, InferOutputsFromConfigs<Args, OutputsCfg, UiState>, UiState, Href>\n  >;\n\n  public done(\n    apiVersion: 2,\n  ): PlatformaExtended<\n    PlatformaV2<Args, InferOutputsFromConfigs<Args, OutputsCfg, UiState>, UiState, Href>\n  >;\n\n  /** Renders all provided block settings into a pre-configured platforma API\n   * instance, that can be used in frontend to interact with block state, and\n   * other features provided by the platforma to the block. */\n  public done(\n    apiVersion: PlatformaApiVersion = 1,\n  ): PlatformaExtended<\n    Platforma<Args, InferOutputsFromConfigs<Args, OutputsCfg, UiState>, UiState, Href>\n  > {\n    return this.withFeatureFlags({\n      ...this.config.featureFlags,\n      requiresUIAPIVersion: apiVersion,\n    }).#done();\n  }\n\n  #done(): PlatformaExtended<\n    Platforma<Args, InferOutputsFromConfigs<Args, OutputsCfg, UiState>, UiState, Href>\n  > {\n    if (this.config.initialArgs === undefined) throw new Error(\"Initial arguments not set.\");\n\n    const config: BlockConfigContainer = {\n      v4: undefined,\n      v3: {\n        configVersion: 3,\n        modelAPIVersion: 1,\n        sdkVersion: PlatformaSDKVersion,\n        renderingMode: this.config.renderingMode,\n        initialArgs: this.config.initialArgs,\n        initialUiState: this.config.initialUiState,\n        inputsValid: this.config.inputsValid,\n        sections: this.config.sections,\n        title: this.config.title,\n        subtitle: this.config.subtitle,\n        tags: this.config.tags,\n        outputs: this.config.outputs,\n        enrichmentTargets: this.config.enrichmentTargets,\n        featureFlags: this.config.featureFlags,\n      },\n\n      // fields below are added to allow previous desktop versions read generated configs\n      sdkVersion: PlatformaSDKVersion,\n      renderingMode: this.config.renderingMode,\n      initialArgs: this.config.initialArgs,\n      inputsValid: downgradeCfgOrLambda(this.config.inputsValid),\n      sections: downgradeCfgOrLambda(this.config.sections),\n      outputs: Object.fromEntries(\n        Object.entries(this.config.outputs).map(([key, value]) => [\n          key,\n          downgradeCfgOrLambda(value),\n        ]),\n      ),\n    };\n\n    globalThis.platformaApiVersion = this.config.featureFlags\n      .requiresUIAPIVersion as PlatformaApiVersion;\n\n    if (!isInUI()) {\n      // we are in the configuration rendering routine, not in actual UI\n      return { config } as any;\n    } else {\n      // normal operation inside the UI\n      return {\n        ...getPlatformaInstance({\n          sdkVersion: PlatformaSDKVersion,\n          apiVersion: platformaApiVersion,\n        }),\n        blockModelInfo: {\n          outputs: Object.fromEntries(\n            Object.entries(this.config.outputs).map(([key, value]) => [\n              key,\n              {\n                withStatus: Boolean(isConfigLambda(value) && value.withStatus),\n              },\n            ]),\n          ),\n          pluginIds: [],\n          featureFlags: this.config.featureFlags,\n          pluginPublicOutputs: {},\n        },\n      };\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AA8CA,IAAa,aAAb,MAAa,WAKX;CAEU;CADV,YACE,QAaA;EAbQ,KAAA,SAAA;CAaP;CAEH,WAAkB,8BAA0D;EAC1E,OAAO;GACL,mBAAmB;GACnB,4BAA4B;GAC5B,sBAAsB;GACtB,yBAAyB;GACzB,sBAAsB;GACtB,wBAAwBA,gCAAAA;EAC1B;CACF;CAgBA,OAAc,OAAO,gBAAoC,SAAqC;EAC5F,OAAO,IAAI,WAA2B;GACpC;GACA,gBAAgB,CAAC;GACjB,SAAS,CAAC;GACV,aAAaC,gBAAAA,aAAa,IAAI;GAC9B,UAAUA,gBAAAA,aAAa,CAAC,CAAC;GACzB,cAAc,WAAW;EAC3B,CAAC;CACH;CAoDA,OACE,KACA,SACA,QAAiC,CAAC,GACW;EAC7C,IAAI,OAAO,YAAY,YAAY;GACjC,MAAM,SAAS,UAAU;GACzB,iBAAA,oBAAoB,cAAc,QAAQ,IAAIC,YAAAA,gBAAgB,CAAC,CAAC;GAChE,OAAO,IAAI,WAAW;IACpB,GAAG,KAAK;IACR,SAAS;KACP,GAAG,KAAK,OAAO;MACd,MAAM;MACL,gBAAgB;MAChB;MACA,GAAG;KACL;IACF;GACF,CAAC;EACH,OACE,OAAO,IAAI,WAAW;GACpB,GAAG,KAAK;GACR,SAAS;IACP,GAAG,KAAK,OAAO;KACd,MAAM;GACT;EACF,CAAC;CAEL;;CAGA,gBAGE,KAAU,IAAQ;EAClB,OAAO,KAAK,OAAO,KAAK,IAAI,EAAE,WAAW,KAAK,CAAC;CACjD;;CAGA,iBAGE,KAAU,IAAQ;EAClB,OAAO,KAAK,OAAO,KAAK,IAAI,EAAE,YAAY,KAAK,CAAC;CAClD;;CAGA,0BAGE,KAAU,IAAQ;EAClB,OAAO,KAAK,OAAO,KAAK,IAAI;GAAE,WAAW;GAAM,YAAY;EAAK,CAAC;CACnE;CAWA,UACE,SACqD;EACrD,IAAI,OAAO,YAAY,YAAY;GACjC,iBAAA,oBAAoB,qBAAqB,QAAQ,IAAIA,YAAAA,gBAAgB,CAAC,CAAC;GACvE,OAAO,IAAI,WAAsC;IAC/C,GAAG,KAAK;IACR,aAAa;KACX,gBAAgB;KAChB,QAAQ;IACV;GACF,CAAC;EACH,OACE,OAAO,IAAI,WAAsC;GAC/C,GAAG,KAAK;GACR,aAAa;EACf,CAAC;CAEL;CAoBA,SACE,cACqD;EACrD,IAAI,MAAM,QAAQ,YAAY,GAC5B,OAAO,KAAK,SAASD,gBAAAA,aAAa,YAAY,CAAC;OAC1C,IAAI,OAAO,iBAAiB,YAAY;GAC7C,iBAAA,oBAAoB,kBAAkB,aAAa,IAAIC,YAAAA,gBAAgB,CAAC,CAAC;GACzE,OAAO,IAAI,WAAsC;IAC/C,GAAG,KAAK;IACR,UAAU;KACR,gBAAgB;KAChB,QAAQ;IACV;GACF,CAAC;EACH,OACE,OAAO,IAAI,WAAsC;GAC/C,GAAG,KAAK;GACR,UAAU;EACZ,CAAC;CAEL;;CAGA,MACE,IAC6C;EAC7C,iBAAA,oBAAoB,eAAe,GAAG,IAAIA,YAAAA,gBAAgB,CAAC,CAAC;EAC5D,OAAO,IAAI,WAA4C;GACrD,GAAG,KAAK;GACR,OAAO;IACL,gBAAgB;IAChB,QAAQ;GACV;EACF,CAAC;CACH;CAEA,SACE,IAC6C;EAC7C,iBAAA,oBAAoB,kBAAkB,GAAG,IAAIA,YAAAA,gBAAgB,CAAC,CAAC;EAC/D,OAAO,IAAI,WAA4C;GACrD,GAAG,KAAK;GACR,UAAU;IACR,gBAAgB;IAChB,QAAQ;GACV;EACF,CAAC;CACH;CAEA,KACE,IAC6C;EAC7C,iBAAA,oBAAoB,cAAc,GAAG,IAAIA,YAAAA,gBAAgB,CAAC,CAAC;EAC3D,OAAO,IAAI,WAA4C;GACrD,GAAG,KAAK;GACR,MAAM;IACJ,gBAAgB;IAChB,QAAQ;GACV;EACF,CAAC;CACH;;;;;CAMA,YAAmB,OAA0D;EAC3E,OAAO,KAAK,SAAS,KAAK;CAC5B;;CAGA,SAAsB,aAAgE;EACpF,OAAO,IAAI,WAA4C;GACrD,GAAG,KAAK;GACR;EACF,CAAC;CACH;;CAGA,YACE,gBAC6C;EAC7C,OAAO,IAAI,WAA4C;GACrD,GAAG,KAAK;GACR;EACF,CAAC;CACH;;CAGA,iBACE,OAC6C;EAC7C,OAAO,IAAI,WAA4C;GACrD,GAAG,KAAK;GACR,cAAc;IACZ,GAAG,KAAK,OAAO;IACf,GAAG;GACL;EACF,CAAC;CACH;;;;;CAMA,SAAgB,QAA8E;EAC5F,iBAAA,oBAAoB,qBAAqB,MAAM;EAC/C,OAAO,IAAI,WAA4C;GACrD,GAAG,KAAK;GACR,mBAAmB;IACjB,gBAAgB;IAChB,QAAQ;GACV;EACF,CAAC;CACH;;;;CAiBA,KACE,aAAkC,GAGlC;EACA,OAAO,KAAK,iBAAiB;GAC3B,GAAG,KAAK,OAAO;GACf,sBAAsB;EACxB,CAAC,CAAC,CAACC,MAAM;CACX;CAEA,QAEE;EACA,IAAI,KAAK,OAAO,gBAAgB,KAAA,GAAW,MAAM,IAAI,MAAM,4BAA4B;EAEvF,MAAM,SAA+B;GACnC,IAAI,KAAA;GACJ,IAAI;IACF,eAAe;IACf,iBAAiB;IACjB,YAAYC,gBAAAA;IACZ,eAAe,KAAK,OAAO;IAC3B,aAAa,KAAK,OAAO;IACzB,gBAAgB,KAAK,OAAO;IAC5B,aAAa,KAAK,OAAO;IACzB,UAAU,KAAK,OAAO;IACtB,OAAO,KAAK,OAAO;IACnB,UAAU,KAAK,OAAO;IACtB,MAAM,KAAK,OAAO;IAClB,SAAS,KAAK,OAAO;IACrB,mBAAmB,KAAK,OAAO;IAC/B,cAAc,KAAK,OAAO;GAC5B;GAGA,YAAYA,gBAAAA;GACZ,eAAe,KAAK,OAAO;GAC3B,aAAa,KAAK,OAAO;GACzB,aAAaC,sBAAAA,qBAAqB,KAAK,OAAO,WAAW;GACzD,UAAUA,sBAAAA,qBAAqB,KAAK,OAAO,QAAQ;GACnD,SAAS,OAAO,YACd,OAAO,QAAQ,KAAK,OAAO,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACxD,KACAA,sBAAAA,qBAAqB,KAAK,CAC5B,CAAC,CACH;EACF;EAEA,WAAW,sBAAsB,KAAK,OAAO,aAC1C;EAEH,IAAI,CAACC,iBAAAA,OAAO,GAEV,OAAO,EAAE,OAAO;OAGhB,OAAO;GACL,GAAGC,iBAAAA,qBAAqB;IACtB,YAAYH,gBAAAA;IACZ,YAAY;GACd,CAAC;GACD,gBAAgB;IACd,SAAS,OAAO,YACd,OAAO,QAAQ,KAAK,OAAO,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACxD,KACA,EACE,YAAY,QAAQI,cAAAA,eAAe,KAAK,KAAK,MAAM,UAAU,EAC/D,CACF,CAAC,CACH;IACA,WAAW,CAAC;IACZ,cAAc,KAAK,OAAO;IAC1B,qBAAqB,CAAC;GACxB;EACF;CAEJ;AACF"}