@platforma-sdk/model 1.57.2 → 1.58.1

package/src/render/api.ts

@@ -50,6 +50,12 @@ import canonicalize from "canonicalize";
 import type { Optional } from "utility-types";
 import { getCfgRenderCtx } from "../internal";
 import { getPluginData } from "../block_storage";
+import type {
+  PluginHandle,
+  PluginFactoryLike,
+  InferFactoryData,
+  InferFactoryParams,
+} from "../plugin_handle";
 import { TreeNodeAccessor, ifDef } from "./accessor";
 import type { FutureRef } from "./future";
 import type { AccessorHandle, GlobalCfgRenderCtx } from "./internal";
@@ -756,40 +762,44 @@ export class RenderCtxLegacy<Args = unknown, UiState = unknown> extends RenderCt
 /**
  * Render context for plugin output functions.
  * Reads plugin data from blockStorage and derives params from pre-wrapped input callbacks.
+ *
+ * Parameterized on the factory-like phantom F so that getPluginData returns
+ * InferFactoryData<F> directly — no casts needed for the data getter.
+ *
+ * @typeParam F - PluginFactoryLike phantom carrying data/params/outputs types
  */
-export class PluginRenderCtx<Data = unknown, Params = unknown> {
+export class PluginRenderCtx<F extends PluginFactoryLike = PluginFactoryLike> {
   private readonly ctx: GlobalCfgRenderCtx;
-  private readonly pluginId: string;
+  private readonly handle: PluginHandle<F>;
   private readonly wrappedInputs: Record<string, () => unknown>;
 
-  constructor(pluginId: string, wrappedInputs: Record<string, () => unknown>) {
+  constructor(handle: PluginHandle<F>, wrappedInputs: Record<string, () => unknown>) {
     this.ctx = getCfgRenderCtx();
-    this.pluginId = pluginId;
+    this.handle = handle;
     this.wrappedInputs = wrappedInputs;
   }
 
-  private dataCache?: { v: Data };
+  private dataCache?: { v: InferFactoryData<F> };
 
   /** Plugin's persistent data from blockStorage.__plugins.{pluginId}.__data */
-  public get data(): Data {
+  public get data(): InferFactoryData<F> {
     if (this.dataCache === undefined) {
       const raw = this.ctx.blockStorage();
-      const pluginData = getPluginData<Data>(parseJson(raw), this.pluginId);
-      this.dataCache = { v: pluginData };
+      this.dataCache = { v: getPluginData(parseJson(raw), this.handle) };
     }
     return this.dataCache.v;
   }
 
-  private paramsCache?: { v: Params };
+  private paramsCache?: { v: InferFactoryParams<F> };
 
   /** Params derived from block context via pre-wrapped input callbacks */
-  public get params(): Params {
+  public get params(): InferFactoryParams<F> {
     if (this.paramsCache === undefined) {
       const result: Record<string, unknown> = {};
       for (const [key, fn] of Object.entries(this.wrappedInputs)) {
         result[key] = fn();
       }
-      this.paramsCache = { v: result as Params };
+      this.paramsCache = { v: result as InferFactoryParams<F> };
     }
     return this.paramsCache.v;
   }