@gi-tcg/gts-runtime 0.3.0 → 0.3.2

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/index.d.ts

@@ -1,149 +1,195 @@
+//#region src/attribute_return.d.ts
 declare namespace AttributeReturn {
-	type This<TMeta> = {
-		"~meta": TMeta;
-	};
-	type EnableIf<
-		Condition,
-		T = void
-	> = Condition extends true ? T : never;
-	type Done = {
-		namedDefinition: {
-			"~meta": void;
-		};
-	};
-	type With<
-		VM extends IViewModel<any, any>,
-		TMeta = VM["~namedDefinition"]["~meta"]
-	> = {
-		namedDefinition: BlockDefinitionRewriteMeta<VM["~namedDefinition"], TMeta>;
-	};
-	type DoneRewriteMeta<NewMeta> = {
-		namedDefinition: {
-			"~meta": void;
-		};
-		rewriteMeta: NewMeta;
-	};
-	type WithRewriteMeta<
-		VM extends IViewModel<any, any>,
-		NewMeta
-	> = {
-		namedDefinition: VM["~namedDefinition"];
-		rewriteMeta: NewMeta;
-	};
+  type This<TMeta> = {
+    "~meta": TMeta;
+  };
+  type EnableIf<Condition, T = void> = Condition extends true ? T : never;
+  type Done = {
+    namedDefinition: {
+      "~meta": void;
+    };
+  };
+  type With<VM extends IViewModel<any, any, any>, TMeta = VM["~namedDefinition"]["~meta"]> = {
+    namedDefinition: BlockDefinitionRewriteMeta<VM["~namedDefinition"], TMeta>;
+  };
+  type DoneRewriteMeta<NewMeta> = {
+    namedDefinition: {
+      "~meta": void;
+    };
+    rewriteMeta: NewMeta;
+  };
+  type WithRewriteMeta<VM extends IViewModel<any, any, any>, NewMeta> = {
+    namedDefinition: VM["~namedDefinition"];
+    rewriteMeta: NewMeta;
+  };
 }
+//#endregion
+//#region src/symbols.d.ts
 type Meta = "~meta";
 type Action = "~action";
 type NamedDefinition = "~namedDefinition";
 type Prelude = "~prelude";
+//#endregion
+//#region src/view.d.ts
 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";
+  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";
 }
 interface NamedAttributesNode {
-	attributes: SingleAttributeNode[];
+  attributes: SingleAttributeNode[];
 }
 declare class View<BlockDef extends AttributeBlockDefinition> {
-	private;
-	_node: NamedAttributesNode;
-	_bindingCtx?: BindingContext | undefined;
-	constructor(_node: NamedAttributesNode, _bindingCtx?: BindingContext | undefined);
+  #private;
+  _node: NamedAttributesNode;
+  _bindingCtx?: BindingContext;
+  constructor(_node: NamedAttributesNode, _bindingCtx?: BindingContext | undefined);
 }
 declare class BindingContext {
-	private;
-	addBinding(value: unknown): void;
-	getBindings(): unknown[];
+  #private;
+  addBinding(value: unknown): void;
+  getBindings(): unknown[];
 }
-declare function createDefine(rootVM: IViewModel<any, any>, node: SingleAttributeNode): void;
-declare function createBinding(rootVM: IViewModel<any, any>, node: SingleAttributeNode): unknown[];
-import { StandardJSONSchemaV1 } from "@standard-schema/spec";
+declare function createDefine(rootVM: IViewModel<any, any, any>, node: SingleAttributeNode): void;
+declare function createBinding(rootVM: IViewModel<any, any, any>, node: SingleAttributeNode): unknown[];
+//#endregion
+//#region ../../node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: StandardJSONSchemaV1.Converter;
+  }
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+  /**
+   * The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+//#region src/view_model.d.ts
 interface AttributeBlockDefinition {
-	"~action"?: AttributeDefinition | undefined;
-	"~meta": any;
+  "~action"?: AttributeDefinition | undefined;
+  "~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;
+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;
-	"~namedDefinition": BlockDef;
+interface IViewModel<ModelT, BlockDef extends AttributeBlockDefinition, CtorArgs extends any[]> {
+  parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>, ...args: CtorArgs): ModelT;
+  "~namedDefinition": BlockDef;
 }
 type LazyAttributeActionOrBinder<ModelT> = (model: ModelT, positionals: () => unknown[], named: View<any>) => unknown;
-declare class ViewModel<
-	ModelT,
-	BlockDef extends AttributeBlockDefinition
-> implements IViewModel<ModelT, BlockDef> {
-	private;
-	"~namedDefinition": BlockDef;
-	constructor(Ctor: new () => ModelT);
-	"~setActionOrBinder"(context: "action" | "binder", name: PropertyKey, action: LazyAttributeActionOrBinder<ModelT>): void;
-	parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>): ModelT;
+declare class ViewModel<ModelT, BlockDef extends AttributeBlockDefinition, CtorArgs extends any[]> implements IViewModel<ModelT, BlockDef, CtorArgs> {
+  #private;
+  "~namedDefinition": BlockDef;
+  constructor(Ctor: new (...args: CtorArgs) => ModelT);
+  "~setActionOrBinder"(context: "action" | "binder", name: PropertyKey, action: LazyAttributeActionOrBinder<ModelT>): void;
+  parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>, ...args: CtorArgs): ModelT;
 }
 declare class AttributeDefHelper<ModelT> {
-	private;
-	constructor(viewModel: ViewModel<ModelT, any>);
-	"~assignActions"(defResult: Partial<Record<string, unknown>>): void;
-	attribute<T extends AttributeDefinition & {
-		as?: undefined;
-	}>(action: AttributeAction<ModelT, T>, binder?: AttributeBinder<ModelT, T> | IViewModel<any, ReturnType<T>["namedDefinition"]>): T;
-	attribute<T extends AttributeDefinition>(action: AttributeAction<ModelT, T>, binder: AttributeBinder<ModelT, T>): T;
-	simpleAttribute<Args extends any[]>(action: (this: ModelT, ...args: Args) => void): {
-		(...args: Args): AttributeReturn.Done;
-	};
-	simpleAttribute<
-		Args extends any[],
-		U
-	>(action: (this: ModelT, ...args: Args) => void, binder: (this: ModelT, ...args: Args) => U): {
-		(...args: Args): AttributeReturn.Done;
-		as?(): U;
-	};
+  #private;
+  constructor(viewModel: ViewModel<ModelT, any, any>);
+  "~assignActions"(defResult: Partial<Record<string, unknown>>): void;
+  attribute<T extends AttributeDefinition & {
+    as?: undefined;
+  }>(action: AttributeAction<ModelT, T>, binder?: AttributeBinder<ModelT, T> | IViewModel<any, ReturnType<T>["namedDefinition"], []>): T;
+  attribute<T extends AttributeDefinition>(action: AttributeAction<ModelT, T>, binder: AttributeBinder<ModelT, T>): T;
+  simpleAttribute<Args extends any[]>(action: (this: ModelT, ...args: Args) => void): {
+    (...args: Args): AttributeReturn.Done;
+  };
+  simpleAttribute<Args extends any[], U>(action: (this: ModelT, ...args: Args) => void, binder: (this: ModelT, ...args: Args) => U): {
+    (...args: Args): AttributeReturn.Done;
+    as?(): U;
+  };
 }
-declare function defineViewModel<
-	T,
-	const BlockDef extends Partial<Record<string | Action, AttributeDefinition>>,
-	InitMeta = void
->(Ctor: new () => T, modelDefFn: (helper: AttributeDefHelper<T>) => BlockDef, initMeta?: InitMeta): IViewModel<T, BlockDef & {
-	"~meta": InitMeta;
-}>;
-type SimpleViewModel<T> = IViewModel<T, { [K in keyof T]-? : {
-	(value: T[K]): AttributeReturn.Done;
-	uniqueKey(): K;
-	required(): {} extends Pick<T, K> ? false : true;
+declare function defineViewModel<T, const BlockDef extends Partial<Record<string | Action, AttributeDefinition>>, CtorArgs extends any[] = [], InitMeta = void>(Ctor: new (...args: CtorArgs) => T, modelDefFn: (helper: AttributeDefHelper<T>) => BlockDef, initMeta?: InitMeta): IViewModel<T, BlockDef & {
+  "~meta": InitMeta;
+}, CtorArgs>;
+type SimpleViewModel<T> = IViewModel<T, { [K in keyof T]-?: {
+  (value: T[K]): AttributeReturn.Done;
+  uniqueKey(): K;
+  required(): {} extends Pick<T, K> ? false : true;
 } } & {
-	"~meta": undefined;
-}>;
+  "~meta": undefined;
+}, []>;
 declare function defineSimpleViewModel<const T extends StandardJSONSchemaV1>(schema: T): SimpleViewModel<StandardJSONSchemaV1.InferInput<T>>;
 interface AttributeDefinition {
-	(...args: any[]): AttributePositionalReturnBase;
-	as?(): any;
-	required?(): boolean;
-	uniqueKey?(): string;
+  (...args: any[]): AttributePositionalReturnBase;
+  as?(): any;
+  required?(): boolean;
+  uniqueKey?(): string;
 }
 interface AttributePositionalReturnBase {
-	rewriteMeta?: any;
-	namedDefinition: AttributeBlockDefinition;
+  rewriteMeta?: any;
+  namedDefinition: AttributeBlockDefinition;
 }
-type AttributeAction<
-	Model,
-	T extends AttributeDefinition
-> = (model: Model, positional: Parameters<T>, named: View<ReturnType<T>["namedDefinition"] extends AttributeBlockDefinition ? ReturnType<T>["namedDefinition"] : {
-	"~meta": void;
+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, defineSimpleViewModel, createDefine, createBinding, View, SingleAttributeNode, SimpleViewModel, Prelude, NamedDefinition, NamedAttributesNode, Meta, IViewModel, AttributeReturn, AttributeDefinition, Action, AttributeReturn as AR };
+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;
+//#endregion
+export { type AttributeReturn as AR, type AttributeReturn, type Action, type AttributeDefinition, type IViewModel, type Meta, type NamedAttributesNode, type NamedDefinition, type Prelude, type SimpleViewModel, type SingleAttributeNode, type View, createBinding, createDefine, defineSimpleViewModel, defineViewModel };

package/dist/index.js

@@ -1,149 +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;
-  }
-}
+//#region src/view.ts
+var View = class {
+	#phantom;
+	_node;
+	_bindingCtx;
+	constructor(_node, _bindingCtx) {
+		this._node = _node;
+		this._bindingCtx = _bindingCtx;
+	}
+};
+var BindingContext = class {
+	#bindings = [];
+	addBinding(value) {
+		this.#bindings.push(value);
+	}
+	getBindings() {
+		return this.#bindings;
+	}
+};
 function createDefine(rootVM, node) {
-  const view = new View({ attributes: [node] });
-  rootVM.parse(view);
+	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 {
-  #registeredActions = new Map;
-  #registeredBinders = new Map;
-  #Ctor;
-  constructor(Ctor) {
-    this.#Ctor = Ctor;
-  }
-  "~setActionOrBinder"(context, name, action) {
-    if (context === "action") {
-      this.#registeredActions.set(name, action);
-    } else {
-      this.#registeredBinders.set(name, action);
-    }
-  }
-  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) {
-        const modelName = this.#Ctor.name;
-        throw new Error(`No action registered for attribute "${String(name)}" on model "${modelName}"`);
-      }
-      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 #lazyActionSlot = Symbol("actionSlot");
-  static #lazyBinderSlot = Symbol("binderSlot");
-  "~assignActions"(defResult) {
-    for (const [name, value] of Object.entries(defResult)) {
-      const actionDescriptor = Object.getOwnPropertyDescriptor(value, AttributeDefHelper.#lazyActionSlot);
-      if (actionDescriptor) {
-        this.#viewModel["~setActionOrBinder"]("action", name, actionDescriptor.value);
-      }
-      const binderDescriptor = Object.getOwnPropertyDescriptor(value, AttributeDefHelper.#lazyBinderSlot);
-      if (binderDescriptor) {
-        this.#viewModel["~setActionOrBinder"]("binder", name, binderDescriptor.value);
-      }
-    }
-  }
-  attribute(action, binder) {
-    const returnValue = {};
-    const lazyAction = (model, positionals, named) => action(model, positionals(), named);
-    Object.defineProperty(returnValue, AttributeDefHelper.#lazyActionSlot, {
-      value: lazyAction,
-      enumerable: true
-    });
-    let lazyBinder;
-    if (typeof binder === "function") {
-      lazyBinder = (model, positionals, named) => binder(model, positionals(), named);
-    } else if (binder) {
-      const vm = binder;
-      lazyBinder = (model, positionals, named) => {
-        return vm.parse(named);
-      };
-    } else {
-      lazyBinder = () => {};
-    }
-    Object.defineProperty(returnValue, AttributeDefHelper.#lazyBinderSlot, {
-      value: lazyBinder,
-      enumerable: true
-    });
-    return returnValue;
-  }
-  simpleAttribute(action, binder) {
-    const action2 = (model, positionals) => action.apply(model, positionals);
-    let binder2;
-    if (binder) {
-      binder2 = (model, positionals) => binder.apply(model, positionals);
-    }
-    return this.attribute(action2, binder2);
-  }
+	const bindingCtx = new BindingContext();
+	const view = new View({ attributes: [node] }, bindingCtx);
+	rootVM.parse(view);
+	return bindingCtx.getBindings();
 }
+//#endregion
+//#region src/view_model.ts
+var ViewModel = class {
+	#registeredActions = /* @__PURE__ */ new Map();
+	#registeredBinders = /* @__PURE__ */ new Map();
+	#Ctor;
+	constructor(Ctor) {
+		this.#Ctor = Ctor;
+	}
+	"~setActionOrBinder"(context, name, action) {
+		if (context === "action") this.#registeredActions.set(name, action);
+		else this.#registeredBinders.set(name, action);
+	}
+	parse(view, ...args) {
+		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}"`);
+			}
+			fn ??= () => {};
+			named ??= { attributes: [] };
+			const value = fn(model, positionals, new View(named, view._bindingCtx));
+			if (binding && view._bindingCtx) view._bindingCtx.addBinding(value);
+		}
+		return model;
+	}
+};
+var AttributeDefHelper = class AttributeDefHelper {
+	#viewModel;
+	constructor(viewModel) {
+		this.#viewModel = viewModel;
+	}
+	static #lazyActionSlot = Symbol("actionSlot");
+	static #lazyBinderSlot = Symbol("binderSlot");
+	"~assignActions"(defResult) {
+		for (const [name, value] of Object.entries(defResult)) {
+			const actionDescriptor = Object.getOwnPropertyDescriptor(value, AttributeDefHelper.#lazyActionSlot);
+			if (actionDescriptor) this.#viewModel["~setActionOrBinder"]("action", name, actionDescriptor.value);
+			const binderDescriptor = Object.getOwnPropertyDescriptor(value, AttributeDefHelper.#lazyBinderSlot);
+			if (binderDescriptor) this.#viewModel["~setActionOrBinder"]("binder", name, binderDescriptor.value);
+		}
+	}
+	attribute(action, binder) {
+		const returnValue = {};
+		const lazyAction = (model, positionals, named) => action(model, positionals(), named);
+		Object.defineProperty(returnValue, AttributeDefHelper.#lazyActionSlot, {
+			value: lazyAction,
+			enumerable: true
+		});
+		let lazyBinder;
+		if (typeof binder === "function") lazyBinder = (model, positionals, named) => binder(model, positionals(), named);
+		else if (binder) {
+			const vm = binder;
+			lazyBinder = (model, positionals, named) => {
+				return vm.parse(named);
+			};
+		} else lazyBinder = () => {};
+		Object.defineProperty(returnValue, AttributeDefHelper.#lazyBinderSlot, {
+			value: lazyBinder,
+			enumerable: true
+		});
+		return returnValue;
+	}
+	simpleAttribute(action, binder) {
+		const action2 = (model, positionals) => action.apply(model, positionals);
+		let binder2;
+		if (binder) binder2 = (model, positionals) => binder.apply(model, positionals);
+		return this.attribute(action2, binder2);
+	}
+};
 function defineViewModel(Ctor, modelDefFn, initMeta) {
-  const vm = new ViewModel(Ctor);
-  const helper = new AttributeDefHelper(vm);
-  const defResult = modelDefFn(helper);
-  helper["~assignActions"](defResult);
-  return vm;
+	const vm = new ViewModel(Ctor);
+	const helper = new AttributeDefHelper(vm);
+	const defResult = modelDefFn(helper);
+	helper["~assignActions"](defResult);
+	return vm;
 }
 function defineSimpleViewModel(schema) {
-  const jsonSchema = schema["~standard"].jsonSchema.input({
-    target: "draft-2020-12"
-  });
-  const Ctor = class SimpleViewModel {
-  };
-  const vm = new ViewModel(Ctor);
-  const helper = new AttributeDefHelper(vm);
-  const defResult = {};
-  for (const key of Object.keys(jsonSchema.properties ?? {})) {
-    defResult[key] = helper.simpleAttribute(function(value) {
-      this[key] = value;
-    });
-  }
-  helper["~assignActions"](defResult);
-  return vm;
+	const jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+	const vm = new ViewModel(class SimpleViewModel {});
+	const helper = new AttributeDefHelper(vm);
+	const defResult = {};
+	for (const key of Object.keys(jsonSchema.properties ?? {})) defResult[key] = helper.simpleAttribute(function(value) {
+		this[key] = value;
+	});
+	helper["~assignActions"](defResult);
+	return vm;
 }
-export {
-  defineViewModel,
-  defineSimpleViewModel,
-  createDefine,
-  createBinding
-};
+//#endregion
+export { createBinding, createDefine, defineSimpleViewModel, defineViewModel };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@gi-tcg/gts-runtime",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "repository": "https://github.com/piovium/gts.git",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "bun": "./src/index.ts",
+      "development": "./src/index.ts",
       "default": "./dist/index.js"
     }
   },
@@ -19,5 +19,8 @@
   "devDependencies": {
     "@standard-schema/spec": "^1.1.0",
     "json-schema-typed": "^8.0.2"
+  },
+  "scripts": {
+    "build": "tsdown --platform neutral"
   }
-}
+}

package/src/attribute_return.ts

@@ -1,4 +1,4 @@
-import type { BlockDefinitionRewriteMeta, IViewModel } from "./view_model";
+import type { BlockDefinitionRewriteMeta, IViewModel } from "./view_model.ts";
 
 export namespace AttributeReturn {
   export type This<TMeta> = {
@@ -14,7 +14,7 @@ export namespace AttributeReturn {
   };
 
   export type With<
-    VM extends IViewModel<any, any>,
+    VM extends IViewModel<any, any, any>,
     TMeta = VM["~namedDefinition"]["~meta"],
   > = {
     namedDefinition: BlockDefinitionRewriteMeta<VM["~namedDefinition"], TMeta>;
@@ -25,7 +25,7 @@ export namespace AttributeReturn {
     rewriteMeta: NewMeta;
   };
 
-  export type WithRewriteMeta<VM extends IViewModel<any, any>, NewMeta> = {
+  export type WithRewriteMeta<VM extends IViewModel<any, any, any>, NewMeta> = {
     namedDefinition: VM["~namedDefinition"];
     rewriteMeta: NewMeta;
   };

package/src/index.ts

@@ -4,9 +4,9 @@ export {
   type AttributeDefinition,
   type IViewModel,
   type SimpleViewModel,
-} from "./view_model";
-export type { AttributeReturn, AR } from "./attribute_return";
-export type { Action, Prelude, Meta, NamedDefinition } from "./symbols";
+} from "./view_model.ts";
+export type { AttributeReturn, AR } from "./attribute_return.ts";
+export type { Action, Prelude, Meta, NamedDefinition } from "./symbols.ts";
 
 export {
   createBinding,
@@ -14,4 +14,4 @@ export {
   type SingleAttributeNode,
   type NamedAttributesNode,
   type View,
-} from "./view";
+} from "./view.ts";

package/src/view.ts

@@ -1,4 +1,4 @@
-import type { AttributeBlockDefinition, IViewModel } from "./view_model";
+import type { AttributeBlockDefinition, IViewModel } from "./view_model.ts";
 
 export type AttributeName = string | symbol;
 
@@ -17,11 +17,16 @@ export interface NamedAttributesNode {
 
 export class View<BlockDef extends AttributeBlockDefinition> {
   #phantom!: BlockDef;
+  _node: NamedAttributesNode;
+  _bindingCtx?: BindingContext;
 
   constructor(
-    public _node: NamedAttributesNode,
-    public _bindingCtx?: BindingContext | undefined,
-  ) {}
+    _node: NamedAttributesNode,
+    _bindingCtx?: BindingContext | undefined,
+  ) {
+    this._node = _node;
+    this._bindingCtx = _bindingCtx;
+  }
 }
 
 export class BindingContext {
@@ -35,7 +40,7 @@ export class BindingContext {
 }
 
 export function createDefine(
-  rootVM: IViewModel<any, any>,
+  rootVM: IViewModel<any, any, any>,
   node: SingleAttributeNode,
 ): void {
   const view = new View<any>({ attributes: [node] });
@@ -43,7 +48,7 @@ export function createDefine(
 }
 
 export function createBinding(
-  rootVM: IViewModel<any, any>,
+  rootVM: IViewModel<any, any, any>,
   node: SingleAttributeNode,
 ): unknown[] {
   const bindingCtx = new BindingContext();

package/src/view_model.ts

@@ -1,7 +1,7 @@
-import { AttributeReturn } from "./attribute_return";
-import { Action, Meta, NamedDefinition } from "./symbols";
-import { View } from "./view";
-import { StandardJSONSchemaV1 } from "@standard-schema/spec";
+import type { AttributeReturn } from "./attribute_return.ts";
+import type { Action, Meta, NamedDefinition } from "./symbols.ts";
+import { View } from "./view.ts";
+import  type { StandardJSONSchemaV1 } from "@standard-schema/spec";
 
 export interface AttributeBlockDefinition {
   "~action"?: AttributeDefinition | undefined;
@@ -21,8 +21,15 @@ export type BlockDefinitionRewriteMeta<
     ? R
     : never;
 
-export interface IViewModel<ModelT, BlockDef extends AttributeBlockDefinition> {
-  parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>): ModelT;
+export interface IViewModel<
+  ModelT,
+  BlockDef extends AttributeBlockDefinition,
+  CtorArgs extends any[],
+> {
+  parse(
+    view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>,
+    ...args: CtorArgs
+  ): ModelT;
   "~namedDefinition": BlockDef;
 }
 
@@ -35,7 +42,8 @@ type LazyAttributeActionOrBinder<ModelT> = (
 class ViewModel<
   ModelT,
   BlockDef extends AttributeBlockDefinition,
-> implements IViewModel<ModelT, BlockDef> {
+  CtorArgs extends any[],
+> implements IViewModel<ModelT, BlockDef, CtorArgs> {
   declare "~namedDefinition": BlockDef;
 
   #registeredActions: Map<PropertyKey, LazyAttributeActionOrBinder<ModelT>> =
@@ -43,9 +51,9 @@ class ViewModel<
   #registeredBinders: Map<PropertyKey, LazyAttributeActionOrBinder<ModelT>> =
     new Map();
 
-  #Ctor: new () => ModelT;
+  #Ctor: new (...args: CtorArgs) => ModelT;
 
-  constructor(Ctor: new () => ModelT) {
+  constructor(Ctor: new (...args: CtorArgs) => ModelT) {
     this.#Ctor = Ctor;
   }
 
@@ -61,8 +69,11 @@ class ViewModel<
     }
   }
 
-  parse(view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>): ModelT {
-    const model = new this.#Ctor();
+  parse(
+    view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>,
+    ...args: CtorArgs
+  ): ModelT {
+    const model = new this.#Ctor(...args);
     for (const attrNode of view._node.attributes) {
       let { name, positionals, named, binding } = attrNode;
       const insideBindingCtx = !!view._bindingCtx;
@@ -87,8 +98,8 @@ class ViewModel<
 }
 
 class AttributeDefHelper<ModelT> {
-  #viewModel: ViewModel<ModelT, any>;
-  constructor(viewModel: ViewModel<ModelT, any>) {
+  #viewModel: ViewModel<ModelT, any, any>;
+  constructor(viewModel: ViewModel<ModelT, any, any>) {
     this.#viewModel = viewModel;
   }
 
@@ -126,7 +137,7 @@ class AttributeDefHelper<ModelT> {
     action: AttributeAction<ModelT, T>,
     binder?:
       | AttributeBinder<ModelT, T>
-      | IViewModel<any, ReturnType<T>["namedDefinition"]>,
+      | IViewModel<any, ReturnType<T>["namedDefinition"], []>,
   ): T;
   attribute<T extends AttributeDefinition>(
     action: AttributeAction<ModelT, T>,
@@ -134,7 +145,7 @@ class AttributeDefHelper<ModelT> {
   ): T;
   attribute(
     action: any,
-    binder?: AttributeBinder<any, any> | IViewModel<any, any>,
+    binder?: AttributeBinder<any, any> | IViewModel<any, any, any>,
   ) {
     const returnValue = {};
     const lazyAction: LazyAttributeActionOrBinder<ModelT> = (
@@ -195,13 +206,14 @@ class AttributeDefHelper<ModelT> {
 export function defineViewModel<
   T,
   const BlockDef extends Partial<Record<string | Action, AttributeDefinition>>,
+  CtorArgs extends any[] = [],
   InitMeta = void,
 >(
-  Ctor: new () => T,
+  Ctor: new (...args: CtorArgs) => T,
   modelDefFn: (helper: AttributeDefHelper<T>) => BlockDef,
   initMeta?: InitMeta,
-): IViewModel<T, BlockDef & { "~meta": InitMeta }> {
-  const vm = new ViewModel<T, BlockDef & { "~meta": InitMeta }>(Ctor);
+): IViewModel<T, BlockDef & { "~meta": InitMeta }, CtorArgs> {
+  const vm = new ViewModel<T, BlockDef & { "~meta": InitMeta }, CtorArgs>(Ctor);
   const helper = new AttributeDefHelper(vm);
   const defResult = modelDefFn(helper);
   helper["~assignActions"](defResult);
@@ -216,7 +228,8 @@ export type SimpleViewModel<T> = IViewModel<
       uniqueKey(): K;
       required(): {} extends Pick<T, K> ? false : true;
     };
-  } & { "~meta": undefined }
+  } & { "~meta": undefined },
+  []
 >;
 
 export function defineSimpleViewModel<const T extends StandardJSONSchemaV1>(
@@ -226,7 +239,7 @@ export function defineSimpleViewModel<const T extends StandardJSONSchemaV1>(
     target: "draft-2020-12",
   });
   const Ctor = class SimpleViewModel {};
-  const vm = new ViewModel<any, any>(Ctor);
+  const vm = new ViewModel<any, any, []>(Ctor);
   const helper = new AttributeDefHelper(vm);
   const defResult: Record<string, any> = {};
   for (const key of Object.keys(jsonSchema.properties ?? {})) {