@gi-tcg/gts-runtime 0.7.4 → 0.7.6

package/dist/index.d.ts

@@ -45,18 +45,32 @@ interface NamedAttributesNode {
 }
 declare class View<BlockDef extends AttributeBlockDefinition> {
   #private;
-  _node: NamedAttributesNode;
-  _bindingCtx?: BindingContext;
-  constructor(_node: NamedAttributesNode, _bindingCtx?: BindingContext | undefined);
-}
-declare class BindingContext {
-  #private;
-  addBinding(value: unknown): void;
-  getBindings(): unknown[];
+  "~node": NamedAttributesNode;
+  constructor(node: NamedAttributesNode);
 }
 declare function createDefine(rootVM: IViewModel<any, any, any>, node: SingleAttributeNode): void;
 declare function createBinding(rootVM: IViewModel<any, any, any>, node: SingleAttributeNode): unknown[];
 //#endregion
+//#region src/execution_context.d.ts
+type RuntimePhase = "action" | "binder";
+/**
+* The ViewModel execution state visible while a Model is being constructed.
+*
+* The context is synchronous and scoped to the current `parse()` call. A View
+* is stable across the binder and action passes for the same definition, while
+* `phase` describes the current pass.
+*/
+interface ModelConstructionContext {
+  readonly view: View<any>;
+  readonly phase: RuntimePhase;
+}
+/** Returns the context for the current synchronous ViewModel parse call. */
+declare function getCurrentModelContext(): ModelConstructionContext | null;
+/** Returns the View currently being parsed, or `null` outside ViewModel parsing. */
+declare function getCurrentView(): View<any> | null;
+/** Returns whether the current ViewModel parse is running actions or binders. */
+declare function getCurrentContext(): RuntimePhase | null;
+//#endregion
 //#region src/view_model.d.ts
 interface AttributeBlockDefinition {
   "~meta": any;
@@ -91,13 +105,12 @@ interface IViewModel<ModelT, BlockDef extends AttributeBlockDefinition, CtorArgs
   bind<This extends IViewModel<any, any, any>>(this: This, ...args: CtorArgs): IReboundViewModel<This, []>;
   /**
   * Rewrite the initial meta.
-  * @param newMeta 
+  * @param newMeta
   */
   narrow<This extends IViewModel<any, any, any>, const NewMeta extends This["~namedDefinition"]["~meta"]>(this: This, newMeta: NewMeta): INarrowedViewModel<This, NewMeta>;
   extend<This extends IViewModel<any, any, any>, ChildT extends ModelT, const ChildBlockDef extends PartialAttributeBlockDefinition, ChildCtorArgs extends any[] = []>(this: This, Ctor: new (...args: ChildCtorArgs) => ChildT, modelDefFn: (helper: AttributeDefHelper<ChildT>) => ChildBlockDef): IExtendedViewModel<This, ChildT, ChildBlockDef, ChildCtorArgs>;
 }
 type LazyAttributeActionOrBinder<ModelT> = (model: ModelT, positionals: () => unknown[], named: View<any>) => unknown;
-declare function getCurrentContext(): "action" | "binder" | null;
 declare class ViewModelRuntime {
   #private;
   constructor(Ctor: new (...args: any[]) => any);
@@ -281,4 +294,19 @@ interface ISimpleViewModel<T, Options extends SimpleViewModelOptions = {}> exten
 }
 declare function defineSimpleViewModel<const T extends StandardJSONSchemaV1, const Options extends SimpleViewModelOptions = {}>(schema: T, options?: Options): ISimpleViewModel<StandardJSONSchemaV1.InferInput<T>, Options>;
 //#endregion
-export { type AttributeReturn as AR, type AttributeReturn, type AttributeBlockDefinition, type AttributeDefinition, type IExtendedViewModel, type INarrowedViewModel, type IReboundViewModel, type ISimpleViewModel, type IViewModel, type IViewModelInstance, type NamedAttributesNode, type SimpleAttributeOptions, type SimpleViewModelOptions, type SingleAttributeNode, type View, createBinding, createDefine, defineSimpleViewModel, defineViewModel, extendViewModel, getCurrentContext };
+//#region src/action_view_model.d.ts
+type AnyAction = (fnArg: any) => void;
+declare class ActionModel<Fn extends AnyAction> {
+  action!: Fn;
+}
+/**
+* Defines a ViewModel whose only attribute is a direct `~action` that assigned to `ActionModel`'s `action`.
+*/
+declare function defineActionViewModel<Signature extends (this: any, actionArg: AnyAction) => AttributeReturn.Done, InitMeta = unknown, ModelActionSig extends AnyAction = OverloadedParameters<Signature>[0]>(): IViewModel<ActionModel<ModelActionSig>, {
+  "~action": Signature & {
+    required(): true;
+  };
+  "~meta": InitMeta;
+}, []>;
+//#endregion
+export { type AttributeReturn as AR, type AttributeReturn, ActionModel, type AttributeBlockDefinition, type AttributeDefinition, type IExtendedViewModel, type INarrowedViewModel, type IReboundViewModel, type ISimpleViewModel, type IViewModel, type IViewModelInstance, type ModelConstructionContext, type NamedAttributesNode, type RuntimePhase, type SimpleAttributeOptions, type SimpleViewModelOptions, type SingleAttributeNode, type View, createBinding, createDefine, defineActionViewModel, defineSimpleViewModel, defineViewModel, extendViewModel, getCurrentContext, getCurrentModelContext, getCurrentView };

package/dist/index.js

@@ -1,12 +1,50 @@
 import { Ajv2020 } from "ajv/dist/2020.js";
+//#region src/execution_context.ts
+let currentExecution = null;
+let currentModelContext = null;
+/** Returns the context for the current synchronous ViewModel parse call. */
+function getCurrentModelContext() {
+	return currentModelContext;
+}
+/** Returns the View currently being parsed, or `null` outside ViewModel parsing. */
+function getCurrentView() {
+	return currentModelContext?.view ?? null;
+}
+/** Returns whether the current ViewModel parse is running actions or binders. */
+function getCurrentContext() {
+	return currentModelContext?.phase ?? null;
+}
+function getCurrentViewModelExecution() {
+	return currentExecution;
+}
+function runInViewModelExecution(execution, callback) {
+	const previousExecution = currentExecution;
+	currentExecution = execution;
+	try {
+		return callback();
+	} finally {
+		currentExecution = previousExecution;
+	}
+}
+function runWithCurrentView(view, callback) {
+	const previousModelContext = currentModelContext;
+	currentModelContext = {
+		view,
+		phase: currentExecution?.phase ?? "action"
+	};
+	try {
+		return callback();
+	} finally {
+		currentModelContext = previousModelContext;
+	}
+}
+//#endregion
 //#region src/view.ts
 var View = class {
 	#phantom;
-	_node;
-	_bindingCtx;
-	constructor(_node, _bindingCtx) {
-		this._node = _node;
-		this._bindingCtx = _bindingCtx;
+	"~node";
+	constructor(node) {
+		this["~node"] = node;
 	}
 };
 var BindingContext = class {
@@ -18,22 +56,37 @@ var BindingContext = class {
 		return this.#bindings;
 	}
 };
+const viewRegistry = /* @__PURE__ */ new WeakMap();
+function getViewForNode(node, kind) {
+	let registered = viewRegistry.get(node);
+	if (!registered) {
+		registered = {};
+		viewRegistry.set(node, registered);
+	}
+	let view = registered[kind];
+	if (!view) {
+		view = new View(kind === "root" ? { attributes: [node] } : node.named ?? { attributes: [] });
+		registered[kind] = view;
+	}
+	return view;
+}
 function createDefine(rootVM, node) {
-	const view = new View({ attributes: [node] });
-	rootVM.parse(view);
+	runInViewModelExecution({ phase: "action" }, () => {
+		rootVM.parse(getViewForNode(node, "root"));
+	});
 }
 function createBinding(rootVM, node) {
 	const bindingCtx = new BindingContext();
-	const view = new View({ attributes: [node] }, bindingCtx);
-	rootVM.parse(view);
+	runInViewModelExecution({
+		phase: "binder",
+		bindingContext: bindingCtx
+	}, () => {
+		rootVM.parse(getViewForNode(node, "root"));
+	});
 	return bindingCtx.getBindings();
 }
 //#endregion
 //#region src/view_model.ts
-let currentContext = null;
-function getCurrentContext() {
-	return currentContext;
-}
 var ViewModelRuntime = class ViewModelRuntime {
 	#registeredActions = /* @__PURE__ */ new Map();
 	#registeredBinders = /* @__PURE__ */ new Map();
@@ -46,23 +99,23 @@ var ViewModelRuntime = class ViewModelRuntime {
 		else this.#registeredBinders.set(name, action);
 	}
 	parse(view, ...args) {
-		currentContext = view._bindingCtx ? "binder" : "action";
-		const model = new this.#Ctor(...args);
-		for (const attrNode of view._node.attributes) {
-			let { name, positionals, named, binding } = attrNode;
-			const insideBindingCtx = !!view._bindingCtx;
-			let fn = (insideBindingCtx ? this.#registeredBinders : this.#registeredActions).get(name);
-			if (!insideBindingCtx && !fn) {
-				const modelName = this.#Ctor.name;
-				throw new Error(`No action registered for attribute "${String(name)}" on model "${modelName}"`);
+		return runWithCurrentView(view, () => {
+			const execution = getCurrentViewModelExecution();
+			const phase = execution?.phase ?? "action";
+			const model = new this.#Ctor(...args);
+			for (const attrNode of view["~node"].attributes) {
+				const { name, positionals, binding } = attrNode;
+				let fn = (phase === "binder" ? this.#registeredBinders : this.#registeredActions).get(name);
+				if (phase === "action" && !fn) {
+					const modelName = this.#Ctor.name;
+					throw new Error(`No action registered for attribute "${String(name)}" on model "${modelName}"`);
+				}
+				fn ??= () => {};
+				const value = fn(model, positionals, getViewForNode(attrNode, "named"));
+				if (binding && execution?.bindingContext) execution.bindingContext.addBinding(value);
 			}
-			fn ??= () => {};
-			named ??= { attributes: [] };
-			const value = fn(model, positionals, new View(named, view._bindingCtx));
-			if (binding && view._bindingCtx) view._bindingCtx.addBinding(value);
-		}
-		currentContext = null;
-		return model;
+			return model;
+		});
 	}
 	#clone(Ctor = this.#Ctor) {
 		const newVMR = new ViewModelRuntime(Ctor);
@@ -236,4 +289,18 @@ function defineSimpleViewModel(schema, options) {
 	return createSimpleViewModelFromJsonSchema(schema["~standard"].jsonSchema.input({ target: "draft-2020-12" }), resolvedOptions);
 }
 //#endregion
-export { createBinding, createDefine, defineSimpleViewModel, defineViewModel, extendViewModel, getCurrentContext };
+//#region src/action_view_model.ts
+var ActionModel = class {
+	action;
+};
+/**
+* Defines a ViewModel whose only attribute is a direct `~action` that assigned to `ActionModel`'s `action`.
+*/
+function defineActionViewModel() {
+	return defineViewModel(ActionModel, (helper) => ({ "~action": helper.attribute((model, [actionArg]) => {
+		model.action = actionArg;
+	}) }), null);
+}
+defineActionViewModel();
+//#endregion
+export { ActionModel, createBinding, createDefine, defineActionViewModel, defineSimpleViewModel, defineViewModel, extendViewModel, getCurrentContext, getCurrentModelContext, getCurrentView };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-runtime",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "repository": {
     "type": "git",
     "url": "https://github.com/piovium/gts.git"

package/src/action_view_model.ts

@@ -0,0 +1,51 @@
+import {
+  type AttributeDefinition,
+  type AttributeDefHelper,
+  defineViewModel,
+  type IViewModel,
+  type OverloadedParameters,
+} from "./view_model.ts";
+import type { AR } from "./attribute_return.ts";
+
+type AnyAction = (fnArg: any) => void;
+
+export class ActionModel<Fn extends AnyAction> {
+  action!: Fn;
+}
+
+/**
+ * Defines a ViewModel whose only attribute is a direct `~action` that assigned to `ActionModel`'s `action`.
+ */
+export function defineActionViewModel<
+  Signature extends (this: any, actionArg: AnyAction) => AR.Done,
+  InitMeta = unknown,
+  ModelActionSig extends AnyAction = OverloadedParameters<Signature>[0],
+>(): IViewModel<
+  ActionModel<ModelActionSig>,
+  {
+    "~action": Signature & {
+      required(): true;
+    };
+    "~meta": InitMeta;
+  },
+  []
+> {
+  return defineViewModel(
+    ActionModel<ModelActionSig>,
+    (helper) => ({
+      "~action": helper.attribute<Signature & { required(): true }>(
+        (model, [actionArg]) => {
+          model.action = actionArg as ModelActionSig;
+        },
+      ),
+    }),
+    null as InitMeta,
+  );
+}
+
+type Operation<Meta> = (arg: { meta: Meta }) => void;
+
+const VM =
+  defineActionViewModel<
+    <Meta>(this: AR.This<Meta>, op: Operation<Meta>) => AR.Done
+  >();

package/src/execution_context.ts

@@ -0,0 +1,68 @@
+import type { BindingContext, View } from "./view.ts";
+
+export type RuntimePhase = "action" | "binder";
+
+/**
+ * The ViewModel execution state visible while a Model is being constructed.
+ *
+ * The context is synchronous and scoped to the current `parse()` call. A View
+ * is stable across the binder and action passes for the same definition, while
+ * `phase` describes the current pass.
+ */
+export interface ModelConstructionContext {
+  readonly view: View<any>;
+  readonly phase: RuntimePhase;
+}
+
+interface ViewModelExecution {
+  readonly phase: RuntimePhase;
+  readonly bindingContext?: BindingContext;
+}
+
+let currentExecution: ViewModelExecution | null = null;
+let currentModelContext: ModelConstructionContext | null = null;
+
+/** Returns the context for the current synchronous ViewModel parse call. */
+export function getCurrentModelContext(): ModelConstructionContext | null {
+  return currentModelContext;
+}
+
+/** Returns the View currently being parsed, or `null` outside ViewModel parsing. */
+export function getCurrentView(): View<any> | null {
+  return currentModelContext?.view ?? null;
+}
+
+/** Returns whether the current ViewModel parse is running actions or binders. */
+export function getCurrentContext(): RuntimePhase | null {
+  return currentModelContext?.phase ?? null;
+}
+
+export function getCurrentViewModelExecution(): ViewModelExecution | null {
+  return currentExecution;
+}
+
+export function runInViewModelExecution<T>(
+  execution: ViewModelExecution,
+  callback: () => T,
+): T {
+  const previousExecution = currentExecution;
+  currentExecution = execution;
+  try {
+    return callback();
+  } finally {
+    currentExecution = previousExecution;
+  }
+}
+
+export function runWithCurrentView<T>(view: View<any>, callback: () => T): T {
+  const previousModelContext = currentModelContext;
+  currentModelContext = {
+    view,
+    phase: currentExecution?.phase ?? "action",
+  };
+  try {
+    return callback();
+  } finally {
+    currentModelContext = previousModelContext;
+  }
+}

package/src/index.ts

@@ -2,6 +2,8 @@ export {
   defineViewModel,
   extendViewModel,
   getCurrentContext,
+  getCurrentModelContext,
+  getCurrentView,
   type AttributeDefinition,
   type IViewModel,
   type IViewModelInstance,
@@ -10,12 +12,15 @@ export {
   type IExtendedViewModel,
   type SimpleAttributeOptions,
   type AttributeBlockDefinition,
+  type ModelConstructionContext,
+  type RuntimePhase,
 } from "./view_model.ts";
 export {
   defineSimpleViewModel,
   type ISimpleViewModel,
   type SimpleViewModelOptions,
 } from "./simple_view_model.ts";
+export { defineActionViewModel, ActionModel } from "./action_view_model.ts";
 export type { AttributeReturn, AR } from "./attribute_return.ts";
 
 export {

package/src/view.ts

@@ -1,4 +1,5 @@
 import type { AttributeBlockDefinition, IViewModel } from "./view_model.ts";
+import { runInViewModelExecution } from "./execution_context.ts";
 
 export type AttributeName = string | symbol;
 
@@ -17,15 +18,10 @@ export interface NamedAttributesNode {
 
 export class View<BlockDef extends AttributeBlockDefinition> {
   #phantom!: BlockDef;
-  _node: NamedAttributesNode;
-  _bindingCtx?: BindingContext;
-
-  constructor(
-    _node: NamedAttributesNode,
-    _bindingCtx?: BindingContext | undefined,
-  ) {
-    this._node = _node;
-    this._bindingCtx = _bindingCtx;
+  "~node": NamedAttributesNode;
+
+  constructor(node: NamedAttributesNode) {
+    this["~node"] = node;
   }
 }
 
@@ -39,12 +35,41 @@ export class BindingContext {
   }
 }
 
+interface RegisteredViews {
+  root?: View<any>;
+  named?: View<any>;
+}
+
+const viewRegistry = new WeakMap<SingleAttributeNode, RegisteredViews>();
+
+export function getViewForNode(
+  node: SingleAttributeNode,
+  kind: "root" | "named",
+): View<any> {
+  let registered = viewRegistry.get(node);
+  if (!registered) {
+    registered = {};
+    viewRegistry.set(node, registered);
+  }
+  let view = registered[kind];
+  if (!view) {
+    view = new View<any>(
+      kind === "root"
+        ? { attributes: [node] }
+        : (node.named ?? { attributes: [] }),
+    );
+    registered[kind] = view;
+  }
+  return view;
+}
+
 export function createDefine(
   rootVM: IViewModel<any, any, any>,
   node: SingleAttributeNode,
 ): void {
-  const view = new View<any>({ attributes: [node] });
-  rootVM.parse(view);
+  runInViewModelExecution({ phase: "action" }, () => {
+    rootVM.parse(getViewForNode(node, "root"));
+  });
 }
 
 export function createBinding(
@@ -52,7 +77,11 @@ export function createBinding(
   node: SingleAttributeNode,
 ): unknown[] {
   const bindingCtx = new BindingContext();
-  const view = new View<any>({ attributes: [node] }, bindingCtx);
-  rootVM.parse(view);
+  runInViewModelExecution(
+    { phase: "binder", bindingContext: bindingCtx },
+    () => {
+      rootVM.parse(getViewForNode(node, "root"));
+    },
+  );
   return bindingCtx.getBindings();
 }

package/src/view_model.ts

@@ -3,7 +3,20 @@ import type {
   AttributeReturn,
   Computed,
 } from "./attribute_return.ts";
-import { View } from "./view.ts";
+import {
+  getCurrentViewModelExecution,
+  runInViewModelExecution,
+  runWithCurrentView,
+} from "./execution_context.ts";
+import { getViewForNode, View } from "./view.ts";
+
+export {
+  getCurrentContext,
+  getCurrentModelContext,
+  getCurrentView,
+  type ModelConstructionContext,
+  type RuntimePhase,
+} from "./execution_context.ts";
 
 export interface AttributeBlockDefinition {
   "~meta": any;
@@ -95,13 +108,16 @@ export interface IViewModel<
 
   /**
    * Rewrite the initial meta.
-   * @param newMeta 
+   * @param newMeta
    */
-  narrow<This extends IViewModel<any, any, any>, const NewMeta extends This["~namedDefinition"]["~meta"]>(
+  narrow<
+    This extends IViewModel<any, any, any>,
+    const NewMeta extends This["~namedDefinition"]["~meta"],
+  >(
     this: This,
     newMeta: NewMeta,
   ): INarrowedViewModel<This, NewMeta>;
-  
+
   extend<
     This extends IViewModel<any, any, any>,
     ChildT extends ModelT,
@@ -120,11 +136,6 @@ type LazyAttributeActionOrBinder<ModelT> = (
   named: View<any>,
 ) => unknown;
 
-let currentContext: "action" | "binder" | null = null;
-export function getCurrentContext(): "action" | "binder" | null {
-  return currentContext;
-}
-
 export class ViewModelRuntime {
   #registeredActions = new Map<PropertyKey, LazyAttributeActionOrBinder<any>>();
   #registeredBinders = new Map<PropertyKey, LazyAttributeActionOrBinder<any>>();
@@ -147,29 +158,33 @@ export class ViewModelRuntime {
   }
 
   parse(view: View<any>, ...args: any[]): any {
-    currentContext = view._bindingCtx ? "binder" : "action";
-    const model = new this.#Ctor(...args);
-    for (const attrNode of view._node.attributes) {
-      let { name, positionals, named, binding } = attrNode;
-      const insideBindingCtx = !!view._bindingCtx;
-      let fn = (
-        insideBindingCtx ? this.#registeredBinders : this.#registeredActions
-      ).get(name);
-      if (!insideBindingCtx && !fn) {
-        const modelName = this.#Ctor.name;
-        throw new Error(
-          `No action registered for attribute "${String(name)}" on model "${modelName}"`,
+    return runWithCurrentView(view, () => {
+      const execution = getCurrentViewModelExecution();
+      const phase = execution?.phase ?? "action";
+      const model = new this.#Ctor(...args);
+      for (const attrNode of view["~node"].attributes) {
+        const { name, positionals, binding } = attrNode;
+        let fn = (
+          phase === "binder" ? this.#registeredBinders : this.#registeredActions
+        ).get(name);
+        if (phase === "action" && !fn) {
+          const modelName = this.#Ctor.name;
+          throw new Error(
+            `No action registered for attribute "${String(name)}" on model "${modelName}"`,
+          );
+        }
+        fn ??= () => {};
+        const value = fn(
+          model,
+          positionals,
+          getViewForNode(attrNode, "named"),
         );
+        if (binding && execution?.bindingContext) {
+          execution.bindingContext.addBinding(value);
+        }
       }
-      fn ??= () => {};
-      named ??= { attributes: [] };
-      const value = fn(model, positionals, new View(named, view._bindingCtx));
-      if (binding && view._bindingCtx) {
-        view._bindingCtx.addBinding(value);
-      }
-    }
-    currentContext = null;
-    return model;
+      return model;
+    });
   }
 
   #clone(Ctor = this.#Ctor): ViewModelRuntime {
@@ -426,24 +441,25 @@ export interface AttributeDefinition {
   mergeMeta?(meta: any, subMeta: any): any;
 }
 
-type OverloadedParameters<T extends (...args: any[]) => any> = T extends {
-  (...args: infer A1): any;
-  (...args: infer A2): any;
-  (...args: infer A3): any;
-  (...args: infer A4): any;
-}
-  ? A1 | A2 | A3 | A4
-  : T extends {
-        (...args: infer A1): any;
-        (...args: infer A2): any;
-        (...args: infer A3): any;
-      }
-    ? A1 | A2 | A3
-    : T extends { (...args: infer A1): any; (...args: infer A2): any }
-      ? A1 | A2
-      : T extends (...args: infer A) => any
-        ? A
-        : never;
+export type OverloadedParameters<T extends (...args: any[]) => any> =
+  T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+    (...args: infer A3): any;
+    (...args: infer A4): any;
+  }
+    ? A1 | A2 | A3 | A4
+    : T extends {
+          (...args: infer A1): any;
+          (...args: infer A2): any;
+          (...args: infer A3): any;
+        }
+      ? A1 | A2 | A3
+      : T extends { (...args: infer A1): any; (...args: infer A2): any }
+        ? A1 | A2
+        : T extends (...args: infer A) => any
+          ? A
+          : never;
 
 export type AttributeAction<Model, T extends AttributeDefinition> = (
   model: Model,