@gi-tcg/gts-runtime 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,142 @@
+declare const Meta: unique symbol;
+type Meta = typeof Meta;
+declare const Action: unique symbol;
+type Action = typeof Action;
+type NamedDefinition = typeof NamedDefinition;
+declare const Prelude: unique symbol;
+type Prelude = typeof Prelude;
+type AllSymbols = {
+	Meta: Meta;
+	Action: Action;
+	NamedDefinition: NamedDefinition;
+	Prelude: Prelude;
+};
+type AttributeName = string | symbol;
+interface SingleAttributeNode {
+	name: AttributeName;
+	/** Lazy evaluation: only evaluate positional expressions when traversing */
+	positionals: () => any[];
+	named: NamedAttributesNode | null;
+	/** Marks this attribute as a binding candidate */
+	binding?: "public" | "private";
+}
+interface NamedAttributesNode {
+	attributes: SingleAttributeNode[];
+}
+declare class View<BlockDef extends AttributeBlockDefinition> {
+	private;
+	_node: NamedAttributesNode;
+	_bindingCtx?: BindingContext | undefined;
+	constructor(_node: NamedAttributesNode, _bindingCtx?: BindingContext | undefined);
+}
+declare class BindingContext {
+	private;
+	addBinding(value: unknown): void;
+	getBindings(): unknown[];
+}
+declare function createDefine(rootVM: ViewModel<any, any>, node: SingleAttributeNode): void;
+declare function createBinding(rootVM: ViewModel<any, any>, node: SingleAttributeNode): unknown[];
+interface AttributeBlockDefinition {
+	[name: string]: AttributeDefinition;
+	[Action]?: AttributeDefinition;
+	[Meta]: any;
+}
+type Computed<T> = T extends infer U extends { [K in keyof T] : unknown } ? U : never;
+type BlockDefinitionRewriteMeta<
+	BlockDef extends AttributeBlockDefinition,
+	NewMeta
+> = Computed<Omit<BlockDef, Meta> & {
+	[Meta]: NewMeta;
+}> extends infer R extends AttributeBlockDefinition ? R : never;
+interface IViewModel<
+	ModelT,
+	BlockDef extends AttributeBlockDefinition
+> {
+	parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>): ModelT;
+}
+interface ViewModel<
+	ModelT,
+	BlockDef extends AttributeBlockDefinition
+> {
+	/**
+	* Helper for fetching symbol types
+	* @internal
+	*/
+	_symbols: AllSymbols;
+	[NamedDefinition]: BlockDef;
+}
+declare class ViewModel<
+	ModelT,
+	BlockDef extends AttributeBlockDefinition
+> implements IViewModel<ModelT, BlockDef> {
+	private;
+	private Ctor;
+	constructor(Ctor: new () => ModelT);
+	_setAction(name: PropertyKey, action: AttributeAction<ModelT, any>): void;
+	_setBinder(name: PropertyKey, binder: AttributeBinder<ModelT, any>): void;
+	parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>): ModelT;
+}
+declare class AttributeDefHelper<ModelT> {
+	private;
+	constructor(viewModel: ViewModel<ModelT, any>);
+	_assignActions(defResult: Record<string, unknown>): void;
+	attribute<T extends AttributeDefinition & {
+		as?: undefined;
+	}>(action: AttributeAction<ModelT, T>, binder?: AttributeBinder<ModelT, T> | ViewModel<any, ReturnType<T>["namedDefinition"]>): T;
+	attribute<T extends AttributeDefinition>(action: AttributeAction<ModelT, T>, binder: AttributeBinder<ModelT, T>): T;
+}
+declare function defineViewModel<
+	T,
+	const BlockDef extends Record<string, AttributeDefinition>,
+	InitMeta = void
+>(Ctor: new () => T, modelDefFn: (helper: AttributeDefHelper<T>) => BlockDef, initMeta?: InitMeta): ViewModel<T, BlockDef & {
+	[Meta]: InitMeta;
+}>;
+interface AttributeDefinition {
+	(...args: any[]): AttributePositionalReturnBase;
+	as?(): any;
+}
+interface AttributePositionalReturnBase {
+	rewriteMeta?: any;
+	namedDefinition: AttributeBlockDefinition;
+}
+declare namespace AttributeReturn {
+	type This<TMeta = any> = {
+		[Meta]: TMeta;
+	};
+	type EnableIf<
+		Condition,
+		T = void
+	> = Condition extends true ? T : never;
+	type Done = {
+		namedDefinition: {
+			[Meta]: void;
+		};
+	};
+	type With<
+		VM extends ViewModel<any, any>,
+		TMeta = VM[NamedDefinition][Meta]
+	> = {
+		namedDefinition: BlockDefinitionRewriteMeta<VM[NamedDefinition], TMeta>;
+	};
+	type WithRewriteMeta<
+		VM extends ViewModel<any, any>,
+		Meta
+	> = {
+		namedDefinition: VM[NamedDefinition];
+		rewriteMeta: Meta;
+	};
+}
+type AttributeAction<
+	Model,
+	T extends AttributeDefinition
+> = (model: Model, positional: () => Parameters<T>, named: View<ReturnType<T>["namedDefinition"] extends AttributeBlockDefinition ? ReturnType<T>["namedDefinition"] : {
+	[Meta]: void;
+}>) => void;
+type AttributeBinder<
+	Model,
+	T extends AttributeDefinition
+> = (model: Model, positional: () => Parameters<T>, named: View<ReturnType<T>["namedDefinition"] extends AttributeBlockDefinition ? ReturnType<T>["namedDefinition"] : {
+	[Meta]: void;
+}>) => T["as"] extends () => infer U ? U : void;
+export { defineViewModel, createDefine, createBinding, Prelude, IViewModel, AttributeReturn, Action };

package/dist/index.js

@@ -0,0 +1,123 @@
+// packages/runtime/src/view.ts
+class View {
+  _node;
+  _bindingCtx;
+  #phantom;
+  constructor(_node, _bindingCtx) {
+    this._node = _node;
+    this._bindingCtx = _bindingCtx;
+  }
+}
+
+class BindingContext {
+  #bindings = [];
+  addBinding(value) {
+    this.#bindings.push(value);
+  }
+  getBindings() {
+    return this.#bindings;
+  }
+}
+function createDefine(rootVM, node) {
+  const view = new View({ attributes: [node] });
+  rootVM.parse(view);
+}
+function createBinding(rootVM, node) {
+  const bindingCtx = new BindingContext;
+  const view = new View({ attributes: [node] }, bindingCtx);
+  rootVM.parse(view);
+  return bindingCtx.getBindings();
+}
+
+// packages/runtime/src/view_model.ts
+class ViewModel {
+  Ctor;
+  #registeredActions = new Map;
+  #registeredBinders = new Map;
+  constructor(Ctor) {
+    this.Ctor = Ctor;
+  }
+  _setAction(name, action) {
+    this.#registeredActions.set(name, action);
+  }
+  _setBinder(name, binder) {
+    this.#registeredBinders.set(name, binder);
+  }
+  parse(view) {
+    const model = new this.Ctor;
+    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) {
+        throw new Error(`No action registered for attribute: ${String(name)}`);
+      }
+      fn ??= () => {};
+      named ??= { attributes: [] };
+      const value = fn(model, positionals, new View(named, view._bindingCtx));
+      if (binding && view._bindingCtx) {
+        view._bindingCtx.addBinding(value);
+      }
+    }
+    return model;
+  }
+}
+
+class AttributeDefHelper {
+  #viewModel;
+  constructor(viewModel) {
+    this.#viewModel = viewModel;
+  }
+  static #actionSlot = Symbol("actionSlot");
+  static #binderSlot = Symbol("binderSlot");
+  _assignActions(defResult) {
+    for (const [name, returnValue] of Object.entries(defResult)) {
+      const actionDescriptor = Object.getOwnPropertyDescriptor(returnValue, AttributeDefHelper.#actionSlot);
+      if (actionDescriptor) {
+        this.#viewModel._setAction(name, actionDescriptor.value);
+      }
+      const binderDescriptor = Object.getOwnPropertyDescriptor(returnValue, AttributeDefHelper.#binderSlot);
+      if (binderDescriptor) {
+        this.#viewModel._setBinder(name, binderDescriptor.value);
+      }
+    }
+  }
+  attribute(action, binder) {
+    if (binder instanceof ViewModel) {
+      const vm = binder;
+      binder = (model, positionals, named) => {
+        return vm.parse(named);
+      };
+    }
+    binder ??= () => {};
+    const returnValue = {};
+    Object.defineProperty(returnValue, AttributeDefHelper.#actionSlot, {
+      value: action,
+      enumerable: true
+    });
+    Object.defineProperty(returnValue, AttributeDefHelper.#binderSlot, {
+      value: binder,
+      enumerable: true
+    });
+    return returnValue;
+  }
+}
+function defineViewModel(Ctor, modelDefFn, initMeta) {
+  const vm = new ViewModel(Ctor);
+  const helper = new AttributeDefHelper(vm);
+  const defResult = modelDefFn(helper);
+  helper._assignActions(defResult);
+  return vm;
+}
+// packages/runtime/src/symbols.ts
+var Meta = Symbol("Meta");
+var Action = Symbol("Action");
+var NamedDefinition = Symbol("NamedDefinition");
+var Prelude = Symbol("Prelude");
+export {
+  defineViewModel,
+  createDefine,
+  createBinding,
+  Prelude,
+  Action
+};

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@gi-tcg/gts-runtime",
+  "version": "0.2.0",
+  "repository": "https://github.com/piovium/gts.git",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "dependencies": {},
+  "devDependencies": {}
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export {
+  defineViewModel,
+  type IViewModel,
+  type AttributeReturn,
+} from "./view_model";
+export { Action, Prelude } from "./symbols";
+
+export { createBinding, createDefine } from "./view";

package/src/symbols.ts

@@ -0,0 +1,18 @@
+export const Meta: unique symbol = Symbol("Meta");
+export type Meta = typeof Meta;
+
+export const Action: unique symbol = Symbol("Action");
+export type Action = typeof Action;
+
+export const NamedDefinition: unique symbol = Symbol("NamedDefinition");
+export type NamedDefinition = typeof NamedDefinition;
+
+export const Prelude: unique symbol = Symbol("Prelude");
+export type Prelude = typeof Prelude;
+
+export type AllSymbols = {
+  Meta: Meta;
+  Action: Action;
+  NamedDefinition: NamedDefinition;
+  Prelude: Prelude;
+};

package/src/view.ts

@@ -0,0 +1,53 @@
+import type { AttributeBlockDefinition, ViewModel } from "./view_model";
+
+export type AttributeName = string | symbol;
+
+export interface SingleAttributeNode {
+  name: AttributeName;
+  /** Lazy evaluation: only evaluate positional expressions when traversing */
+  positionals: () => any[];
+  named: NamedAttributesNode | null;
+  /** Marks this attribute as a binding export candidate */
+  binding?: "public" | "private";
+}
+
+export interface NamedAttributesNode {
+  attributes: SingleAttributeNode[];
+}
+
+export class View<BlockDef extends AttributeBlockDefinition> {
+  #phantom!: BlockDef;
+
+  constructor(
+    public _node: NamedAttributesNode,
+    public _bindingCtx?: BindingContext | undefined,
+  ) {}
+}
+
+export class BindingContext {
+  #bindings: unknown[] = [];
+  addBinding(value: unknown): void {
+    this.#bindings.push(value);
+  }
+  getBindings(): unknown[] {
+    return this.#bindings;
+  }
+}
+
+export function createDefine(
+  rootVM: ViewModel<any, any>,
+  node: SingleAttributeNode,
+): void {
+  const view = new View<any>({ attributes: [node] });
+  rootVM.parse(view);
+}
+
+export function createBinding(
+  rootVM: ViewModel<any, any>,
+  node: SingleAttributeNode,
+): unknown[] {
+  const bindingCtx = new BindingContext();
+  const view = new View<any>({ attributes: [node] }, bindingCtx);
+  rootVM.parse(view);
+  return bindingCtx.getBindings();
+}

package/src/view_model.ts

@@ -0,0 +1,211 @@
+import { Action, AllSymbols, Meta, NamedDefinition } from "./symbols";
+import { View } from "./view";
+
+export interface AttributeBlockDefinition {
+  [name: string]: AttributeDefinition;
+  [Action]?: AttributeDefinition;
+  [Meta]: any;
+}
+
+type Computed<T> = T extends infer U extends { [K in keyof T]: unknown }
+  ? U
+  : never;
+
+type BlockDefinitionRewriteMeta<
+  BlockDef extends AttributeBlockDefinition,
+  NewMeta,
+> =
+  Computed<Omit<BlockDef, Meta> & { [Meta]: NewMeta }> extends infer R extends
+    AttributeBlockDefinition
+    ? R
+    : never;
+
+export interface IViewModel<ModelT, BlockDef extends AttributeBlockDefinition> {
+  parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>): ModelT;
+}
+
+export interface ViewModel<ModelT, BlockDef extends AttributeBlockDefinition> {
+  /**
+   * Helper for fetching symbol types
+   * @internal
+   */
+  _symbols: AllSymbols;
+  [NamedDefinition]: BlockDef;
+}
+
+export class ViewModel<
+  ModelT,
+  BlockDef extends AttributeBlockDefinition,
+> implements IViewModel<ModelT, BlockDef> {
+  #registeredActions: Map<PropertyKey, AttributeAction<ModelT, any>> =
+    new Map();
+  #registeredBinders: Map<PropertyKey, AttributeBinder<ModelT, any>> =
+    new Map();
+
+  constructor(private Ctor: new () => ModelT) {}
+
+  _setAction(name: PropertyKey, action: AttributeAction<ModelT, any>): void {
+    this.#registeredActions.set(name, action);
+  }
+  _setBinder(name: PropertyKey, binder: AttributeBinder<ModelT, any>): void {
+    this.#registeredBinders.set(name, binder);
+  }
+
+  parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>): ModelT {
+    const model = new this.Ctor();
+    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) {
+        throw new Error(`No action registered for attribute: ${String(name)}`);
+      }
+      fn ??= () => {};
+      named ??= { attributes: [] };
+      const value = fn(model, positionals, new View(named, view._bindingCtx));
+      if (binding && view._bindingCtx) {
+        view._bindingCtx.addBinding(value);
+      }
+    }
+    return model;
+  }
+}
+
+class AttributeDefHelper<ModelT> {
+  #viewModel: ViewModel<ModelT, any>;
+  constructor(viewModel: ViewModel<ModelT, any>) {
+    this.#viewModel = viewModel;
+  }
+
+  static readonly #actionSlot: unique symbol = Symbol("actionSlot");
+  static readonly #binderSlot: unique symbol = Symbol("binderSlot");
+
+  _assignActions(defResult: Record<string, unknown>): void {
+    for (const [name, returnValue] of Object.entries(defResult)) {
+      const actionDescriptor = Object.getOwnPropertyDescriptor(
+        returnValue,
+        AttributeDefHelper.#actionSlot,
+      );
+      if (actionDescriptor) {
+        this.#viewModel._setAction(name, actionDescriptor.value);
+      }
+      const binderDescriptor = Object.getOwnPropertyDescriptor(
+        returnValue,
+        AttributeDefHelper.#binderSlot,
+      );
+      if (binderDescriptor) {
+        this.#viewModel._setBinder(name, binderDescriptor.value);
+      }
+    }
+  }
+
+  attribute<T extends AttributeDefinition & { as?: undefined }>(
+    action: AttributeAction<ModelT, T>,
+    binder?:
+      | AttributeBinder<ModelT, T>
+      | ViewModel<any, ReturnType<T>["namedDefinition"]>,
+  ): T;
+  attribute<T extends AttributeDefinition>(
+    action: AttributeAction<ModelT, T>,
+    binder: AttributeBinder<ModelT, T>,
+  ): T;
+  attribute(
+    action: any,
+    binder?: AttributeBinder<any, any> | ViewModel<any, any>,
+  ) {
+    if (binder instanceof ViewModel) {
+      const vm = binder;
+      binder = (model, positionals, named) => {
+        return vm.parse(named);
+      };
+    }
+    binder ??= () => {};
+    const returnValue = {};
+    Object.defineProperty(returnValue, AttributeDefHelper.#actionSlot, {
+      value: action,
+      enumerable: true,
+    });
+    Object.defineProperty(returnValue, AttributeDefHelper.#binderSlot, {
+      value: binder,
+      enumerable: true,
+    });
+    return returnValue;
+  }
+}
+
+export function defineViewModel<
+  T,
+  const BlockDef extends Record<string, AttributeDefinition>,
+  InitMeta = void,
+>(
+  Ctor: new () => T,
+  modelDefFn: (helper: AttributeDefHelper<T>) => BlockDef,
+  initMeta?: InitMeta,
+): ViewModel<T, BlockDef & { [Meta]: InitMeta }> {
+  const vm = new ViewModel<T, BlockDef & { [Meta]: InitMeta }>(Ctor);
+  const helper = new AttributeDefHelper(vm);
+  const defResult = modelDefFn(helper);
+  helper._assignActions(defResult);
+  return vm;
+}
+
+interface AttributeDefinition {
+  (...args: any[]): AttributePositionalReturnBase;
+  as?(): any;
+  // required?(): boolean;
+}
+
+interface AttributePositionalReturnBase {
+  rewriteMeta?: any;
+  namedDefinition: AttributeBlockDefinition;
+}
+
+export namespace AttributeReturn {
+  export type This<TMeta = any> = {
+    [Meta]: TMeta;
+  };
+
+  export type EnableIf<Condition, T = void> = Condition extends true
+    ? T
+    : never;
+
+  export type Done = {
+    namedDefinition: { [Meta]: void };
+  };
+
+  export type With<
+    VM extends ViewModel<any, any>,
+    TMeta = VM[NamedDefinition][Meta],
+  > = {
+    namedDefinition: BlockDefinitionRewriteMeta<VM[NamedDefinition], TMeta>;
+  };
+
+  export type WithRewriteMeta<VM extends ViewModel<any, any>, Meta> = {
+    namedDefinition: VM[NamedDefinition];
+    rewriteMeta: Meta;
+  };
+}
+
+export type { AttributeReturn as AR };
+
+export type AttributeAction<Model, T extends AttributeDefinition> = (
+  model: Model,
+  positional: () => Parameters<T>,
+  named: View<
+    ReturnType<T>["namedDefinition"] extends AttributeBlockDefinition
+      ? ReturnType<T>["namedDefinition"]
+      : { [Meta]: void }
+  >,
+) => void;
+
+export type AttributeBinder<Model, T extends AttributeDefinition> = (
+  model: Model,
+  positional: () => Parameters<T>,
+  named: View<
+    ReturnType<T>["namedDefinition"] extends AttributeBlockDefinition
+      ? ReturnType<T>["namedDefinition"]
+      : { [Meta]: void }
+  >,
+) => T["as"] extends () => infer U ? U : void;