@gi-tcg/gts-runtime 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -1,16 +1,40 @@
-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;
-};
+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 Meta = "~meta";
+type Action = "~action";
+type NamedDefinition = "~namedDefinition";
+type Prelude = "~prelude";
 type AttributeName = string | symbol;
 interface SingleAttributeNode {
 	name: AttributeName;
@@ -34,109 +58,95 @@ declare class BindingContext {
 	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[];
+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";
 interface AttributeBlockDefinition {
-	[name: string]: AttributeDefinition;
-	[Action]?: AttributeDefinition;
-	[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;
+	"~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
+	BlockDef extends AttributeBlockDefinition,
+	CtorArgs extends any[]
 > {
-	/**
-	* Helper for fetching symbol types
-	* @internal
-	*/
-	_symbols: AllSymbols;
-	[NamedDefinition]: BlockDef;
+	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> {
+	BlockDef extends AttributeBlockDefinition,
+	CtorArgs extends any[]
+> implements IViewModel<ModelT, BlockDef, CtorArgs> {
 	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;
+	"~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: Record<string, unknown>): void;
+	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> | ViewModel<any, ReturnType<T>["namedDefinition"]>): T;
+	}>(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 Record<string, AttributeDefinition>,
+	const BlockDef extends Partial<Record<string | Action, AttributeDefinition>>,
+	CtorArgs extends any[] = [],
 	InitMeta = void
->(Ctor: new () => T, modelDefFn: (helper: AttributeDefHelper<T>) => BlockDef, initMeta?: InitMeta): ViewModel<T, BlockDef & {
-	[Meta]: InitMeta;
-}>;
+>(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;
+}, []>;
+declare function defineSimpleViewModel<const T extends StandardJSONSchemaV1>(schema: T): SimpleViewModel<StandardJSONSchemaV1.InferInput<T>>;
 interface AttributeDefinition {
 	(...args: any[]): AttributePositionalReturnBase;
 	as?(): any;
+	required?(): boolean;
+	uniqueKey?(): string;
 }
 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;
+> = (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;
+> = (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 };
+export { defineViewModel, defineSimpleViewModel, createDefine, createBinding, View, SingleAttributeNode, SimpleViewModel, Prelude, NamedDefinition, NamedAttributesNode, Meta, IViewModel, AttributeReturn, AttributeDefinition, Action, AttributeReturn as AR };

package/dist/index.js

@@ -31,26 +31,28 @@ function createBinding(rootVM, node) {
 
 // packages/runtime/src/view_model.ts
 class ViewModel {
-  Ctor;
   #registeredActions = new Map;
   #registeredBinders = new Map;
+  #Ctor;
   constructor(Ctor) {
-    this.Ctor = Ctor;
+    this.#Ctor = Ctor;
   }
-  _setAction(name, action) {
-    this.#registeredActions.set(name, action);
-  }
-  _setBinder(name, binder) {
-    this.#registeredBinders.set(name, binder);
+  "~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;
+  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) {
-        throw new Error(`No action registered for attribute: ${String(name)}`);
+        const modelName = this.#Ctor.name;
+        throw new Error(`No action registered for attribute "${String(name)}" on model "${modelName}"`);
       }
       fn ??= () => {};
       named ??= { attributes: [] };
@@ -68,56 +70,80 @@ class AttributeDefHelper {
   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);
+  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._setAction(name, actionDescriptor.value);
+        this.#viewModel["~setActionOrBinder"]("action", name, actionDescriptor.value);
       }
-      const binderDescriptor = Object.getOwnPropertyDescriptor(returnValue, AttributeDefHelper.#binderSlot);
+      const binderDescriptor = Object.getOwnPropertyDescriptor(value, AttributeDefHelper.#lazyBinderSlot);
       if (binderDescriptor) {
-        this.#viewModel._setBinder(name, binderDescriptor.value);
+        this.#viewModel["~setActionOrBinder"]("binder", name, binderDescriptor.value);
       }
     }
   }
   attribute(action, binder) {
-    if (binder instanceof ViewModel) {
+    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;
-      binder = (model, positionals, named) => {
+      lazyBinder = (model, positionals, named) => {
         return vm.parse(named);
       };
+    } else {
+      lazyBinder = () => {};
     }
-    binder ??= () => {};
-    const returnValue = {};
-    Object.defineProperty(returnValue, AttributeDefHelper.#actionSlot, {
-      value: action,
-      enumerable: true
-    });
-    Object.defineProperty(returnValue, AttributeDefHelper.#binderSlot, {
-      value: binder,
+    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);
+  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;
 }
-// packages/runtime/src/symbols.ts
-var Meta = Symbol("Meta");
-var Action = Symbol("Action");
-var NamedDefinition = Symbol("NamedDefinition");
-var Prelude = Symbol("Prelude");
 export {
   defineViewModel,
+  defineSimpleViewModel,
   createDefine,
-  createBinding,
-  Prelude,
-  Action
+  createBinding
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-runtime",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "repository": "https://github.com/piovium/gts.git",
   "license": "Apache-2.0",
   "type": "module",
@@ -16,5 +16,8 @@
     "dist"
   ],
   "dependencies": {},
-  "devDependencies": {}
+  "devDependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "json-schema-typed": "^8.0.2"
+  }
 }

package/src/attribute_return.ts

@@ -0,0 +1,34 @@
+import type { BlockDefinitionRewriteMeta, IViewModel } from "./view_model";
+
+export namespace AttributeReturn {
+  export type This<TMeta> = {
+    "~meta": TMeta;
+  };
+
+  export type EnableIf<Condition, T = void> = Condition extends true
+    ? T
+    : never;
+
+  export type Done = {
+    namedDefinition: { "~meta": void };
+  };
+
+  export type With<
+    VM extends IViewModel<any, any>,
+    TMeta = VM["~namedDefinition"]["~meta"],
+  > = {
+    namedDefinition: BlockDefinitionRewriteMeta<VM["~namedDefinition"], TMeta>;
+  };
+
+  export type DoneRewriteMeta<NewMeta> = {
+    namedDefinition: { "~meta": void };
+    rewriteMeta: NewMeta;
+  };
+
+  export type WithRewriteMeta<VM extends IViewModel<any, any>, NewMeta> = {
+    namedDefinition: VM["~namedDefinition"];
+    rewriteMeta: NewMeta;
+  };
+}
+
+export type { AttributeReturn as AR };

package/src/index.ts

@@ -1,8 +1,17 @@
 export {
   defineViewModel,
+  defineSimpleViewModel,
+  type AttributeDefinition,
   type IViewModel,
-  type AttributeReturn,
+  type SimpleViewModel,
 } from "./view_model";
-export { Action, Prelude } from "./symbols";
+export type { AttributeReturn, AR } from "./attribute_return";
+export type { Action, Prelude, Meta, NamedDefinition } from "./symbols";
 
-export { createBinding, createDefine } from "./view";
+export {
+  createBinding,
+  createDefine,
+  type SingleAttributeNode,
+  type NamedAttributesNode,
+  type View,
+} from "./view";

package/src/symbols.ts

@@ -1,18 +1,4 @@
-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;
-};
+export type Meta = "~meta";
+export type Action = "~action";
+export type NamedDefinition = "~namedDefinition";
+export type Prelude = "~prelude";

package/src/view.ts

@@ -1,4 +1,4 @@
-import type { AttributeBlockDefinition, ViewModel } from "./view_model";
+import type { AttributeBlockDefinition, IViewModel } from "./view_model";
 
 export type AttributeName = string | symbol;
 
@@ -35,7 +35,7 @@ export class BindingContext {
 }
 
 export function createDefine(
-  rootVM: ViewModel<any, any>,
+  rootVM: IViewModel<any, any>,
   node: SingleAttributeNode,
 ): void {
   const view = new View<any>({ attributes: [node] });
@@ -43,7 +43,7 @@ export function createDefine(
 }
 
 export function createBinding(
-  rootVM: ViewModel<any, any>,
+  rootVM: IViewModel<any, any>,
   node: SingleAttributeNode,
 ): unknown[] {
   const bindingCtx = new BindingContext();

package/src/view_model.ts

@@ -1,58 +1,79 @@
-import { Action, AllSymbols, Meta, NamedDefinition } from "./symbols";
+import { AttributeReturn } from "./attribute_return";
+import { Action, Meta, NamedDefinition } from "./symbols";
 import { View } from "./view";
+import { StandardJSONSchemaV1 } from "@standard-schema/spec";
 
 export interface AttributeBlockDefinition {
-  [name: string]: AttributeDefinition;
-  [Action]?: AttributeDefinition;
-  [Meta]: any;
+  "~action"?: AttributeDefinition | undefined;
+  "~meta": any;
 }
 
 type Computed<T> = T extends infer U extends { [K in keyof T]: unknown }
   ? U
   : never;
 
-type BlockDefinitionRewriteMeta<
+export type BlockDefinitionRewriteMeta<
   BlockDef extends AttributeBlockDefinition,
   NewMeta,
 > =
-  Computed<Omit<BlockDef, Meta> & { [Meta]: NewMeta }> extends infer R extends
+  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 IViewModel<
+  ModelT,
+  BlockDef extends AttributeBlockDefinition,
+  CtorArgs extends any[],
+> {
+  parse(
+    view: View<BlockDefinitionRewriteMeta<BlockDef, unknown>>,
+    ...args: CtorArgs
+  ): ModelT;
+  "~namedDefinition": BlockDef;
 }
 
-export interface ViewModel<ModelT, BlockDef extends AttributeBlockDefinition> {
-  /**
-   * Helper for fetching symbol types
-   * @internal
-   */
-  _symbols: AllSymbols;
-  [NamedDefinition]: BlockDef;
-}
+type LazyAttributeActionOrBinder<ModelT> = (
+  model: ModelT,
+  positionals: () => unknown[],
+  named: View<any>,
+) => unknown;
 
-export class ViewModel<
+class ViewModel<
   ModelT,
   BlockDef extends AttributeBlockDefinition,
-> implements IViewModel<ModelT, BlockDef> {
-  #registeredActions: Map<PropertyKey, AttributeAction<ModelT, any>> =
+  CtorArgs extends any[],
+> implements IViewModel<ModelT, BlockDef, CtorArgs> {
+  declare "~namedDefinition": BlockDef;
+
+  #registeredActions: Map<PropertyKey, LazyAttributeActionOrBinder<ModelT>> =
     new Map();
-  #registeredBinders: Map<PropertyKey, AttributeBinder<ModelT, any>> =
+  #registeredBinders: Map<PropertyKey, LazyAttributeActionOrBinder<ModelT>> =
     new Map();
 
-  constructor(private Ctor: new () => ModelT) {}
+  #Ctor: new (...args: CtorArgs) => ModelT;
 
-  _setAction(name: PropertyKey, action: AttributeAction<ModelT, any>): void {
-    this.#registeredActions.set(name, action);
+  constructor(Ctor: new (...args: CtorArgs) => ModelT) {
+    this.#Ctor = Ctor;
   }
-  _setBinder(name: PropertyKey, binder: AttributeBinder<ModelT, any>): void {
-    this.#registeredBinders.set(name, binder);
+
+  "~setActionOrBinder"(
+    context: "action" | "binder",
+    name: PropertyKey,
+    action: LazyAttributeActionOrBinder<ModelT>,
+  ): void {
+    if (context === "action") {
+      this.#registeredActions.set(name, action);
+    } else {
+      this.#registeredBinders.set(name, action);
+    }
   }
 
-  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;
@@ -60,7 +81,10 @@ export class ViewModel<
         insideBindingCtx ? this.#registeredBinders : this.#registeredActions
       ).get(name);
       if (!insideBindingCtx && !fn) {
-        throw new Error(`No action registered for attribute: ${String(name)}`);
+        const modelName = this.#Ctor.name;
+        throw new Error(
+          `No action registered for attribute "${String(name)}" on model "${modelName}"`,
+        );
       }
       fn ??= () => {};
       named ??= { attributes: [] };
@@ -74,29 +98,37 @@ export 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;
   }
 
-  static readonly #actionSlot: unique symbol = Symbol("actionSlot");
-  static readonly #binderSlot: unique symbol = Symbol("binderSlot");
+  static readonly #lazyActionSlot: unique symbol = Symbol("actionSlot");
+  static readonly #lazyBinderSlot: unique symbol = Symbol("binderSlot");
 
-  _assignActions(defResult: Record<string, unknown>): void {
-    for (const [name, returnValue] of Object.entries(defResult)) {
+  "~assignActions"(defResult: Partial<Record<string, unknown>>): void {
+    for (const [name, value] of Object.entries(defResult)) {
       const actionDescriptor = Object.getOwnPropertyDescriptor(
-        returnValue,
-        AttributeDefHelper.#actionSlot,
+        value,
+        AttributeDefHelper.#lazyActionSlot,
       );
       if (actionDescriptor) {
-        this.#viewModel._setAction(name, actionDescriptor.value);
+        this.#viewModel["~setActionOrBinder"](
+          "action",
+          name,
+          actionDescriptor.value,
+        );
       }
       const binderDescriptor = Object.getOwnPropertyDescriptor(
-        returnValue,
-        AttributeDefHelper.#binderSlot,
+        value,
+        AttributeDefHelper.#lazyBinderSlot,
       );
       if (binderDescriptor) {
-        this.#viewModel._setBinder(name, binderDescriptor.value);
+        this.#viewModel["~setActionOrBinder"](
+          "binder",
+          name,
+          binderDescriptor.value,
+        );
       }
     }
   }
@@ -105,7 +137,7 @@ class AttributeDefHelper<ModelT> {
     action: AttributeAction<ModelT, T>,
     binder?:
       | AttributeBinder<ModelT, T>
-      | ViewModel<any, ReturnType<T>["namedDefinition"]>,
+      | IViewModel<any, ReturnType<T>["namedDefinition"], []>,
   ): T;
   attribute<T extends AttributeDefinition>(
     action: AttributeAction<ModelT, T>,
@@ -113,48 +145,117 @@ class AttributeDefHelper<ModelT> {
   ): T;
   attribute(
     action: any,
-    binder?: AttributeBinder<any, any> | ViewModel<any, any>,
+    binder?: AttributeBinder<any, any> | IViewModel<any, any, any>,
   ) {
-    if (binder instanceof ViewModel) {
+    const returnValue = {};
+    const lazyAction: LazyAttributeActionOrBinder<ModelT> = (
+      model,
+      positionals,
+      named,
+    ) => action(model, positionals(), named);
+    Object.defineProperty(returnValue, AttributeDefHelper.#lazyActionSlot, {
+      value: lazyAction,
+      enumerable: true,
+    });
+    let lazyBinder: LazyAttributeActionOrBinder<ModelT>;
+    if (typeof binder === "function") {
+      lazyBinder = (model, positionals, named) =>
+        binder(model, positionals(), named);
+    } else if (binder) {
       const vm = binder;
-      binder = (model, positionals, named) => {
+      lazyBinder = (model, positionals, named) => {
         return vm.parse(named);
       };
+    } else {
+      lazyBinder = () => {};
     }
-    binder ??= () => {};
-    const returnValue = {};
-    Object.defineProperty(returnValue, AttributeDefHelper.#actionSlot, {
-      value: action,
-      enumerable: true,
-    });
-    Object.defineProperty(returnValue, AttributeDefHelper.#binderSlot, {
-      value: binder,
+    Object.defineProperty(returnValue, AttributeDefHelper.#lazyBinderSlot, {
+      value: lazyBinder,
       enumerable: true,
     });
     return returnValue;
   }
+
+  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;
+  };
+  simpleAttribute<Args extends any[], U>(
+    action: (this: ModelT, ...args: Args) => void,
+    binder?: (this: ModelT, ...args: Args) => U,
+  ) {
+    const action2: AttributeAction<ModelT, any> = (model, positionals) =>
+      action.apply(model, positionals as Args);
+    let binder2: AttributeBinder<ModelT, any> | undefined;
+    if (binder) {
+      binder2 = (model, positionals) =>
+        binder.apply(model, positionals as Args);
+    }
+    return this.attribute<any>(action2, binder2);
+  }
 }
 
 export function defineViewModel<
   T,
-  const BlockDef extends Record<string, AttributeDefinition>,
+  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,
-): ViewModel<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);
+  helper["~assignActions"](defResult);
+  return vm;
+}
+
+export 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 },
+  []
+>;
+
+export function defineSimpleViewModel<const T extends StandardJSONSchemaV1>(
+  schema: T,
+): SimpleViewModel<StandardJSONSchemaV1.InferInput<T>> {
+  const jsonSchema = schema["~standard"].jsonSchema.input({
+    target: "draft-2020-12",
+  });
+  const Ctor = class SimpleViewModel {};
+  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 ?? {})) {
+    defResult[key] = helper.simpleAttribute(function (this: any, value) {
+      this[key] = value;
+    });
+  }
+  helper["~assignActions"](defResult);
   return vm;
 }
 
-interface AttributeDefinition {
+export interface AttributeDefinition {
   (...args: any[]): AttributePositionalReturnBase;
   as?(): any;
-  // required?(): boolean;
+  required?(): boolean;
+  uniqueKey?(): string;
 }
 
 interface AttributePositionalReturnBase {
@@ -162,50 +263,22 @@ interface AttributePositionalReturnBase {
   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>,
+  positional: Parameters<T>,
   named: View<
     ReturnType<T>["namedDefinition"] extends AttributeBlockDefinition
       ? ReturnType<T>["namedDefinition"]
-      : { [Meta]: void }
+      : { "~meta": void }
   >,
 ) => void;
 
 export type AttributeBinder<Model, T extends AttributeDefinition> = (
   model: Model,
-  positional: () => Parameters<T>,
+  positional: Parameters<T>,
   named: View<
     ReturnType<T>["namedDefinition"] extends AttributeBlockDefinition
       ? ReturnType<T>["namedDefinition"]
-      : { [Meta]: void }
+      : { "~meta": void }
   >,
 ) => T["as"] extends () => infer U ? U : void;