@platforma-sdk/model 1.82.0 → 1.83.9

package/src/bconfig/lambdas.ts

@@ -1,6 +1,5 @@
-import type { ConfigResult, PlResourceEntry, TypedConfig } from "../config";
+import type { PlResourceEntry } from "../config";
 import type { OutputWithStatus } from "@milaboratories/pl-model-common";
-import type { TypedConfigOrConfigLambda } from "./types";
 
 export type StdCtxArgsOnly<Args, Data = undefined> = {
   readonly $blockId: string;
@@ -15,11 +14,6 @@ export type StdCtx<Args, Data = undefined> = StdCtxArgsOnly<Args, Data> & {
   readonly $staging: PlResourceEntry;
 };
 
-export type ResolveCfgType<Cfg extends TypedConfig, Args, UiState = undefined> = ConfigResult<
-  Cfg,
-  StdCtx<Args, UiState>
->;
-
 /** Additional information that may alter lambda rendering procedure. */
 export type ConfigRenderLambdaFlags = {
   /**
@@ -56,24 +50,6 @@ export interface ConfigRenderLambda<Return = unknown> extends ConfigRenderLambda
 export type ExtractFunctionHandleReturn<Func extends ConfigRenderLambda> =
   Func extends ConfigRenderLambda<infer Return> ? Return : never;
 
-/** Infers the output type from a TypedConfig or ConfigRenderLambda */
-export type InferOutputType<CfgOrFH, Args, UiState> = CfgOrFH extends TypedConfig
-  ? ResolveCfgType<CfgOrFH, Args, UiState>
-  : CfgOrFH extends ConfigRenderLambda
-    ? ExtractFunctionHandleReturn<CfgOrFH>
-    : never;
-
-/** Maps outputs configuration to inferred output types with status wrapper */
-export type InferOutputsFromConfigs<
-  Args,
-  OutputsCfg extends Record<string, TypedConfigOrConfigLambda>,
-  UiState,
-> = {
-  [Key in keyof OutputsCfg]: OutputWithStatus<InferOutputType<OutputsCfg[Key], Args, UiState>> & {
-    __unwrap: OutputsCfg[Key] extends { withStatus: true } ? false : true;
-  };
-};
-
 /** Maps lambda-only outputs configuration to inferred output types (for V3 blocks) */
 export type InferOutputsFromLambdas<OutputsCfg extends Record<string, ConfigRenderLambda>> = {
   [Key in keyof OutputsCfg]: OutputWithStatus<ExtractFunctionHandleReturn<OutputsCfg[Key]>> & {

package/src/components/PlDataTable/columnResolver.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import {
   createLocalPObjectId,
   createColumnOverriddenId,
@@ -97,7 +97,7 @@ describe("createColumnResolver", () => {
     expect(r({ type: "column", id: other })).toBeUndefined();
   });
 
-  test("collision warns once and keeps first", () => {
+  test("collision keeps first", () => {
     const pid = createLocalPObjectId(["main", "out"], "col-1");
     const wrappedA = wrap(pid, "A");
     const wrappedB = wrap(pid, "B");
@@ -113,9 +113,7 @@ describe("createColumnResolver", () => {
       return r;
     };
 
-    const warn = vi.fn();
-    const r = createColumnResolver([makeFake(wrappedA), makeFake(wrappedB)], { warn });
-    expect(warn).toHaveBeenCalledTimes(1);
+    const r = createColumnResolver([makeFake(wrappedA), makeFake(wrappedB)]);
     const out = r({ type: "column", id: pid });
     expect(out).toEqual({ type: "column", id: wrappedA });
   });

package/src/components/PlDataTable/columnResolver.ts

@@ -20,10 +20,7 @@ import type { ColumnRecipe } from "../../columns";
  */
 export type ColumnResolver = (ref: PTableColumnId) => PTableColumnId | undefined;
 
-export function createColumnResolver(
-  columns: ColumnRecipe[],
-  deps?: { warn?: (msg: string) => void },
-): ColumnResolver {
+export function createColumnResolver(columns: ColumnRecipe[]): ColumnResolver {
   const axisIds: AxisId[] = [];
   for (const c of columns) {
     for (const ax of c.getSpec().axesSpec) {
@@ -36,14 +33,7 @@ export function createColumnResolver(
   for (const c of columns) {
     byFullId.set(c.id, c);
     const pid = extractPObjectId(c.id);
-    const existing = byPObjectId.get(pid);
-    if (existing === undefined) {
-      byPObjectId.set(pid, c);
-    } else if (existing.id !== c.id) {
-      deps?.warn?.(
-        `Ambiguous PObjectId ${pid}: recipe ids ${existing.id} and ${c.id} both match — keeping first.`,
-      );
-    }
+    if (!byPObjectId.has(pid)) byPObjectId.set(pid, c);
   }
 
   return (ref: PTableColumnId): PTableColumnId | undefined => {

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

@@ -82,10 +82,7 @@ export function createPlDataTableV2<A, U>(
 
   const fullColumns = [...columns, ...fullLabelColumns];
 
-  const resolver = createColumnResolver(
-    fullColumns.map((c) => DataColumn.fromColumn(c)),
-    { warn: ctx.logWarn.bind(ctx) },
-  );
+  const resolver = createColumnResolver(fullColumns.map((c) => DataColumn.fromColumn(c)));
 
   // -- Filtering: rewrite via resolver, throw if any reference is unresolved --
   const rawFilters = tableStateNormalized.pTableParams.filters;

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

@@ -132,10 +132,11 @@ export function createPlDataTableV3<A, U>(
   );
   const orderByColId = evaluateRules(options.displayOptions?.ordering ?? [], allColumnsForRules);
 
-  const resolver = createColumnResolver(
-    [...primary, ...direct, ...linked.flatMap((lc) => [...collectLinkerColumns(lc), lc])],
-    { warn: ctx.logWarn.bind(ctx) },
-  );
+  const resolver = createColumnResolver([
+    ...primary,
+    ...direct,
+    ...linked.flatMap((lc) => [...collectLinkerColumns(lc), lc]),
+  ]);
 
   const remapedDefaultFilters = remapFilterColumnIds(options.filters, resolver);
   const filters = filterFilters(

package/src/config/index.ts

@@ -1,6 +1,2 @@
-export * from "./actions";
-export * from "./actions_kinds";
 export * from "./model";
-export * from "./model_meta";
 export * from "./type_engine";
-export { type Checked } from "./type_util";

package/src/config/type_engine.ts

@@ -1,54 +1,11 @@
-import type { ActGetImmediate } from "./actions_kinds";
 import type { Cfg } from "./model";
 
-// Higher kind types pattern taken from here: https://code.lol/post/programming/higher-kinded-types/
-
-type GenericFunction = (x: any) => unknown;
-
-/** This is a type constructor deriving a returned type of config given the
- * context type. Something like ConfAction<Cfg> -> ReturnedType.  */
-export interface ConfAction {
-  readonly ctx: unknown;
-  new: GenericFunction;
-  isSync: boolean;
-}
-
-/** This type basically sets parameter to a ConfAction kind. */
-export type ActionResult<A extends ConfAction, Ctx> = ReturnType<
-  (A & {
-    readonly ctx: Ctx;
-  })["new"]
->;
-
-// Branding pattern taken from here: https://egghead.io/blog/using-branded-types-in-typescript
-
-/** Field key to attach ConfAction information to a config type. */
-declare const __config_action__: unique symbol;
-
-/** Creates branded Cfg type */
-export type TypedConfig<Action extends ConfAction = ConfAction> = Cfg & {
-  [__config_action__]: Action;
-};
-
-export type PrimitiveOrConfig = TypedConfig | string | number | boolean | null;
-
-/** Converts primitive types to immediate config */
-export type PrimitiveToCfg<T extends PrimitiveOrConfig> = T extends string | number | boolean | null
-  ? TypedConfig<ActGetImmediate<T>>
-  : T;
-
-/** Extracts action */
-export type ExtractAction<Cfg extends TypedConfig> = Cfg[typeof __config_action__];
-
-export type POCExtractAction<T extends PrimitiveOrConfig> = ExtractAction<PrimitiveToCfg<T>>;
-
-export type InferVarTypeSafe<Ctx, V> = V extends string
-  ? Ctx extends { [key in V]: infer T }
-    ? T
-    : undefined
-  : unknown;
-
-export type ConfigResult<Cfg extends TypedConfig, Ctx> = ActionResult<ExtractAction<Cfg>, Ctx>;
+/** Config tree of an already published block, as stored in its compiled model.
+ *
+ * Nothing in the SDK builds these any more — the builder DSL that produced them
+ * went away with the v1/v2 block model. The type is kept because the middle
+ * layer still has to read and render configs of blocks published before that. */
+export type TypedConfig = Cfg;
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 declare const plResourceEntry: unique symbol;

package/src/index.ts

@@ -22,7 +22,6 @@ export {
   getPluginData,
 } from "./block_storage";
 export * from "./block_storage_facade";
-export * from "./block_model_legacy";
 export { BlockModelV3 } from "./block_model";
 export type { PluginRecord, ParamsInput } from "./block_model";
 export { DataModel, DataModelBuilder } from "./block_migrations";
@@ -47,7 +46,6 @@ export * from "./pframe";
 export * from "./labels";
 export * from "./columns";
 export * from "./platforma";
-export * from "./ref_util";
 export * from "./render";
 export * from "./version";
 export * from "./raw_globals";

package/src/render/api.ts

@@ -728,34 +728,6 @@ export class BlockRenderCtx<Args = unknown, Data = unknown> extends RenderCtxBas
   }
 }
 
-/** Render context for legacy v1/v2 blocks - provides backward compatibility */
-export class RenderCtxLegacy<Args = unknown, UiState = unknown> 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;
-  }
-}
-
 /**
  * Render context for plugin output functions.
  * Reads plugin data from blockStorage and derives params from pre-wrapped input callbacks.
@@ -811,10 +783,6 @@ export type RenderFunction<Args = unknown, State = unknown, Ret = unknown> = (
   rCtx: BlockRenderCtx<Args, State>,
 ) => Ret;
 
-export type RenderFunctionLegacy<Args = unknown, State = unknown, Ret = unknown> = (
-  rCtx: RenderCtxLegacy<Args, State>,
-) => Ret;
-
 export type UnwrapFutureRef<K> =
   K extends FutureRef<infer T>
     ? T

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