@platforma-sdk/model 1.65.9 → 1.66.2

package/src/render/api.ts

@@ -3,6 +3,7 @@ import type {
   AnyFunction,
   AxisId,
   DataInfo,
+  ModelServices,
   Option,
   PColumn,
   PColumnLazy,
@@ -23,7 +24,6 @@ import type {
   PlRef,
   ResolveAnchorsOptions,
   ResultCollection,
-  ServiceName,
   SUniversalPColumnId,
   ValueOrError,
 } from "@milaboratories/pl-model-common";
@@ -55,11 +55,8 @@ import type {
   PluginHandle,
   PluginFactoryLike,
   InferFactoryData,
-  InferFactoryModelServices,
   InferFactoryParams,
 } from "../plugin_handle";
-import type { BlockDefaultModelServices } from "../services/service_resolve";
-import type { ModelServices as AllModelServices } from "@milaboratories/pl-model-common";
 import { TreeNodeAccessor, ifDef } from "./accessor";
 import type { FutureRef } from "./future";
 import type { AccessorHandle, GlobalCfgRenderCtx } from "./internal";
@@ -75,6 +72,7 @@ import type { APColumnSelectorWithSplit } from "./util/split_selectors";
 import { patchInSetFilters } from "./util/pframe_upgraders";
 import { allPColumnsReady } from "./util/pcolumn_data";
 import type { PColumnDataUniversal } from "./internal";
+import { getService } from "../services";
 
 /**
  * Helper function to match domain objects
@@ -554,40 +552,11 @@ export class ResultPool implements ColumnProvider, AxisLabelProvider {
 }
 
 /** Main entry point to the API available within model lambdas (like outputs, sections, etc..) */
-export abstract class RenderCtxBase<
-  Args = unknown,
-  Data = unknown,
-  ModelServices = Partial<AllModelServices>,
-> {
+export abstract class RenderCtxBase<Args = unknown, Data = unknown> {
   protected readonly ctx: GlobalCfgRenderCtx;
-  private readonly requiredServiceNames: ServiceName[];
-  private cachedServices?: ModelServices;
 
-  constructor(requiredServiceNames: ServiceName[] = []) {
+  constructor() {
     this.ctx = getCfgRenderCtx();
-    this.requiredServiceNames = requiredServiceNames;
-  }
-
-  get services(): ModelServices {
-    if (this.cachedServices) return this.cachedServices;
-    const ctx = this.ctx;
-    const services = Object.freeze(
-      Object.fromEntries(
-        this.requiredServiceNames.map((id) => [
-          id,
-          Object.freeze(
-            Object.fromEntries(
-              (ctx.getServiceMethods(id) as string[]).map((method) => [
-                method,
-                (...args: unknown[]) => ctx.callServiceMethod(id, method, ...args),
-              ]),
-            ),
-          ),
-        ]),
-      ),
-    ) as ModelServices;
-    this.cachedServices = services;
-    return services;
   }
 
   private dataCache?: { v: Data };
@@ -619,6 +588,10 @@ export abstract class RenderCtxBase<
     return this.activeArgsCache.v;
   }
 
+  public getService<T extends keyof ModelServices>(name: T): ModelServices[T] {
+    return getService(name);
+  }
+
   // /** Can be used to determine features provided by the desktop instance. */
   // public get featureFlags() {
   //   return this.ctx.featureFlags;
@@ -771,11 +744,7 @@ export abstract class RenderCtxBase<
 }
 
 /** Main entry point to the API available within model lambdas (like outputs, sections, etc..) for v3+ blocks */
-export class BlockRenderCtx<
-  Args = unknown,
-  Data = unknown,
-  ModelServices = BlockDefaultModelServices,
-> extends RenderCtxBase<Args, Data, ModelServices> {
+export class BlockRenderCtx<Args = unknown, Data = unknown> extends RenderCtxBase<Args, Data> {
   private argsCache?: { v: Args | undefined };
   public get args(): Args | undefined {
     if (this.argsCache === undefined) {
@@ -824,19 +793,15 @@ export class RenderCtxLegacy<Args = unknown, UiState = unknown> extends RenderCt
  *
  * @typeParam F - PluginFactoryLike phantom carrying data/params/outputs types
  */
-export class PluginRenderCtx<
-  F extends PluginFactoryLike = PluginFactoryLike,
-  ModelServices = InferFactoryModelServices<F>,
-> extends RenderCtxBase<unknown, InferFactoryData<F>, ModelServices> {
+export class PluginRenderCtx<F extends PluginFactoryLike = PluginFactoryLike> extends RenderCtxBase<
+  unknown,
+  InferFactoryData<F>
+> {
   private readonly handle: PluginHandle<F>;
   private readonly wrappedInputs: Record<string, () => unknown>;
 
-  constructor(
-    handle: PluginHandle<F>,
-    wrappedInputs: Record<string, () => unknown>,
-    requiredServiceNames: ServiceName[] = [],
-  ) {
-    super(requiredServiceNames);
+  constructor(handle: PluginHandle<F>, wrappedInputs: Record<string, () => unknown>) {
+    super();
     this.handle = handle;
     this.wrappedInputs = wrappedInputs;
   }

package/src/services/get_services.ts

@@ -0,0 +1,28 @@
+import { ModelServices, ServiceName } from "@milaboratories/pl-model-common";
+import { getCfgRenderCtx } from "../internal";
+import { ValueOf } from "@milaboratories/helpers";
+import { createServiceProxy } from "./service_bridge";
+import { GlobalCfgRenderCtx } from "../render/internal";
+
+const cachedServices = new WeakMap<
+  GlobalCfgRenderCtx,
+  Map<keyof ModelServices, ValueOf<ModelServices>>
+>();
+
+export function getService<T extends keyof ModelServices>(name: T): ModelServices[T] {
+  const ctx = getCfgRenderCtx();
+
+  const map = cachedServices.has(ctx)
+    ? cachedServices.get(ctx)!
+    : (() => {
+        cachedServices.set(ctx, new Map());
+        return cachedServices.get(ctx)!;
+      })();
+
+  return map.has(name)
+    ? (map.get(name) as ModelServices[T])
+    : (() => {
+        map.set(name, createServiceProxy(ctx)(name as ServiceName) as ModelServices[T]);
+        return map.get(name) as ModelServices[T];
+      })();
+}

package/src/services/index.ts

@@ -1,3 +1,4 @@
 export * from "./block_services";
 export * from "./service_resolve";
 export * from "./service_bridge";
+export * from "./get_services";

package/src/services/service_bridge.ts

@@ -15,7 +15,7 @@ import { UiServiceRegistry } from "@milaboratories/pl-model-common";
 // Makes a remote node service appear local.
 // Given a service ID, returns an object implementing the service's UI interface.
 // Provided by the desktop app (e.g. backed by Electron IPC).
-export type NodeServiceProxy = <S extends ServiceTypesLike>(
+export type ServiceProxy = <S extends ServiceTypesLike>(
   serviceId: ServiceName<S>,
 ) => InferServiceUi<S>;
 
@@ -53,10 +53,10 @@ export function buildServices<S extends Partial<AllUiServices> = Partial<AllUiSe
 }
 
 /**
- * Builds a NodeServiceProxy from a ServiceDispatch.
+ * Builds a ServiceProxy from a ServiceDispatch.
  * Each service method call is forwarded to dispatch.callServiceMethod.
  */
-export function createNodeServiceProxy(dispatch: ServiceDispatch): NodeServiceProxy {
+export function createServiceProxy(dispatch: ServiceDispatch): ServiceProxy {
   return ((serviceId: ServiceName) =>
     Object.freeze(
       Object.fromEntries(
@@ -64,8 +64,8 @@ export function createNodeServiceProxy(dispatch: ServiceDispatch): NodeServicePr
           .getServiceMethods(serviceId)
           .map((method) => [
             method,
-            async (...args: unknown[]) => dispatch.callServiceMethod(serviceId, method, ...args),
+            (...args: unknown[]) => dispatch.callServiceMethod(serviceId, method, ...args),
           ]),
       ),
-    )) as NodeServiceProxy;
+    )) as ServiceProxy;
 }