@diphyx/harlemify 4.0.1 → 5.1.0

package/dist/runtime/core/store.d.ts

@@ -1,23 +1,5 @@
-import type { ComputedRef } from "vue";
-import type { Model, ModelFactory } from "./types/model.js";
-import type { ViewDefinitions, ViewResult, ViewFactory } from "./types/view.js";
-import { type Action, type ActionApiChain, type ActionCommitChain, type ActionCommitter, type ActionDefinition, type ActionDefinitions, type ActionFactory, type ActionHandleChain } from "./types/action.js";
-export type StoreModel<M extends Model> = ActionCommitter<M>;
-export type StoreView<M extends Model, VD extends ViewDefinitions<M>> = {
-    readonly [K in keyof VD]: ComputedRef<ViewResult<M, VD[K]>>;
-};
-export type StoreAction<M extends Model, V, AD extends Record<string, ActionDefinition<M, V, unknown>>> = {
-    [K in keyof AD]: Action<V>;
-};
-export interface StoreConfig<M extends Model, VD extends ViewDefinitions<M>, _AD extends ActionDefinitions<M, StoreView<M, VD>>> {
-    name: string;
-    model: (factory: ModelFactory) => M;
-    view: (factory: ViewFactory<M>) => VD;
-    action: (factory: ActionFactory<M, StoreView<M, VD>>) => Record<string, ActionApiChain<M, StoreView<M, VD>, unknown> | ActionHandleChain<M, StoreView<M, VD>, unknown> | ActionCommitChain<M, StoreView<M, VD>, unknown>>;
-}
-export interface Store<M extends Model, VD extends ViewDefinitions<M>, AD extends ActionDefinitions<M, StoreView<M, VD>>> {
-    model: StoreModel<M>;
-    view: StoreView<M, VD>;
-    action: StoreAction<M, StoreView<M, VD>, AD>;
-}
-export declare function createStore<M extends Model, VD extends ViewDefinitions<M>, AD extends ActionDefinitions<M, StoreView<M, VD>>>(config: StoreConfig<M, VD, AD>): Store<M, VD, AD>;
+import type { ModelDefinitions } from "./types/model.js";
+import type { ViewDefinitions } from "./types/view.js";
+import type { ActionDefinitions } from "./types/action.js";
+import type { Store, StoreConfig } from "./types/store.js";
+export declare function createStore<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>>(config: StoreConfig<MD, VD, AD>): Store<MD, VD, AD>;

package/dist/runtime/core/store.js

@@ -1,28 +1,10 @@
 import { createConsola } from "consola";
-import { createStore as createSourceStore } from "@harlem/core";
+import { createStore as createStoreSource } from "@harlem/core";
 import { runtimeConfig } from "../config.js";
 import { createModelFactory } from "./layers/model.js";
 import { createViewFactory } from "./layers/view.js";
 import { createActionFactory } from "./layers/action.js";
-import { initializeState, createMutations, createCommitter } from "./utils/model.js";
-import { createView } from "./utils/view.js";
-import { createAction } from "./utils/action.js";
-import {
-  DEFINITION
-} from "./types/action.js";
-function createStoreModel(mutations) {
-  return createCommitter(mutations);
-}
-function createStoreView(source, viewDefinitions) {
-  return createView(source, viewDefinitions);
-}
-function createStoreAction(actionDefinitions, view, mutations) {
-  const actions = {};
-  for (const [key, chain] of Object.entries(actionDefinitions)) {
-    actions[key] = createAction(chain[DEFINITION], mutations, view, key);
-  }
-  return actions;
-}
+import { createStoreState, createStoreModel, createStoreView, createStoreAction } from "./utils/store.js";
 export function createStore(config) {
   const logger = createConsola({
     level: runtimeConfig.logger,
@@ -30,20 +12,18 @@ export function createStore(config) {
       tag: `harlemify:${config.name}`
     }
   });
+  logger.info("Creating store");
   const modelFactory = createModelFactory(runtimeConfig.model, logger);
   const viewFactory = createViewFactory(runtimeConfig.view, logger);
   const actionFactory = createActionFactory(runtimeConfig.action, logger);
-  logger.info("Creating store");
   const modelDefinitions = config.model(modelFactory);
   const viewDefinitions = config.view(viewFactory);
   const actionDefinitions = config.action(actionFactory);
-  logger.debug("Initializing store");
-  const state = initializeState(modelDefinitions);
-  const source = createSourceStore(config.name, state);
-  const mutations = createMutations(source, modelDefinitions);
-  const model = createStoreModel(mutations);
-  const view = createStoreView(source, viewDefinitions);
-  const action = createStoreAction(actionDefinitions, view, mutations);
+  const state = createStoreState(modelDefinitions);
+  const source = createStoreSource(config.name, state);
+  const model = createStoreModel(modelDefinitions, source);
+  const view = createStoreView(viewDefinitions, source);
+  const action = createStoreAction(actionDefinitions, model, view);
   logger.info("Store created");
   return {
     model,

package/dist/runtime/core/types/action.d.ts

@@ -1,6 +1,8 @@
-import type { ConsolaInstance } from "consola";
 import type { ComputedRef, DeepReadonly, MaybeRefOrGetter, Ref } from "vue";
-import type { Model, ModelShape, MutationsOneOptions, MutationsManyOptions } from "./model.js";
+import type { BaseDefinition } from "./base.js";
+import type { ModelDefinitions, ModelOneCommitOptions, ModelManyCommitOptions, StoreModel } from "./model.js";
+import { ModelOneMode, ModelManyMode } from "./model.js";
+import type { ViewDefinitions, StoreView } from "./view.js";
 export interface RuntimeActionConfig {
     endpoint?: string;
     headers?: Record<string, string>;
@@ -8,20 +10,6 @@ export interface RuntimeActionConfig {
     timeout?: number;
     concurrent?: ActionConcurrent;
 }
-export declare const DEFINITION: unique symbol;
-export declare const AUTO: unique symbol;
-export declare enum ActionOneMode {
-    SET = "set",
-    RESET = "reset",
-    PATCH = "patch"
-}
-export declare enum ActionManyMode {
-    SET = "set",
-    RESET = "reset",
-    PATCH = "patch",
-    REMOVE = "remove",
-    ADD = "add"
-}
 export declare enum ActionStatus {
     IDLE = "idle",
     PENDING = "pending",
@@ -42,122 +30,92 @@ export declare enum ActionApiMethod {
     PATCH = "PATCH",
     DELETE = "DELETE"
 }
-export interface ActionApiError extends Error {
-    name: "ActionApiError";
-    status?: number;
-    statusText?: string;
-    data?: unknown;
-}
-export interface ActionHandleError extends Error {
-    name: "ActionHandleError";
-    cause: Error;
-}
-export interface ActionCommitError extends Error {
-    name: "ActionCommitError";
-    cause: Error;
-}
-export interface ActionConcurrentError extends Error {
-    name: "ActionConcurrentError";
-}
-export type ActionError = ActionApiError | ActionHandleError | ActionCommitError | ActionConcurrentError;
-export type ActionApiValue<V, T> = MaybeRefOrGetter<T> | ((view: DeepReadonly<V>) => T);
-export interface ActionApiDefinition<V> {
+export type ActionApiRequestValue<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, T> = MaybeRefOrGetter<T> | ((view: DeepReadonly<StoreView<MD, VD>>) => T);
+export interface ActionApiRequest<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
     endpoint?: string;
-    url: ActionApiValue<V, string>;
-    method: ActionApiMethod;
-    headers?: ActionApiValue<V, Record<string, string>>;
-    query?: ActionApiValue<V, Record<string, unknown>>;
-    body?: ActionApiValue<V, unknown>;
-    timeout?: number;
+    url: ActionApiRequestValue<MD, VD, string>;
+    method: ActionApiRequestValue<MD, VD, ActionApiMethod>;
+    headers?: ActionApiRequestValue<MD, VD, Record<string, string>>;
+    query?: ActionApiRequestValue<MD, VD, Record<string, unknown>>;
+    body?: ActionApiRequestValue<MD, VD, unknown>;
+    timeout?: ActionApiRequestValue<MD, VD, number>;
     concurrent?: ActionConcurrent;
 }
-export type DeepPartial<T> = T extends object ? {
-    [K in keyof T]?: DeepPartial<T[K]>;
-} : T;
-export type ActionCommitValue<M extends Model, K extends keyof M, Mode> = Mode extends ActionOneMode.SET ? ModelShape<M, K> : Mode extends ActionOneMode.PATCH ? DeepPartial<ModelShape<M, K>> : Mode extends ActionOneMode.RESET ? never : Mode extends ActionManyMode.SET ? ModelShape<M, K>[] : Mode extends ActionManyMode.PATCH ? DeepPartial<ModelShape<M, K>> | DeepPartial<ModelShape<M, K>>[] : Mode extends ActionManyMode.REMOVE ? ModelShape<M, K> | ModelShape<M, K>[] : Mode extends ActionManyMode.ADD ? ModelShape<M, K> | ModelShape<M, K>[] : Mode extends ActionManyMode.RESET ? never : never;
-export type ActionCommitter<M extends Model> = {
-    <K extends keyof M, Mode extends ActionOneMode>(model: K, mode: Mode, ...args: Mode extends ActionOneMode.RESET ? [] : [value: ActionCommitValue<M, K, Mode>, options?: MutationsOneOptions]): void;
-    <K extends keyof M, Mode extends ActionManyMode>(model: K, mode: Mode, ...args: Mode extends ActionManyMode.RESET ? [] : [value: ActionCommitValue<M, K, Mode>, options?: MutationsManyOptions]): void;
+export type ActionApiRequestShortcut<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Omit<ActionApiRequest<MD, VD>, "method">;
+export interface ActionApiCommit<MD extends ModelDefinitions> {
+    model: keyof MD;
+    mode: ModelOneMode | ModelManyMode;
+    value?: (data: unknown) => unknown;
+    options?: ModelOneCommitOptions | ModelManyCommitOptions;
+}
+export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> extends BaseDefinition {
+    request: ActionApiRequest<MD, VD>;
+    commit?: ActionApiCommit<MD>;
+}
+export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> = (context: {
+    model: StoreModel<MD>;
+    view: StoreView<MD, VD>;
+}) => Promise<R>;
+export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> extends BaseDefinition {
+    callback: ActionHandlerCallback<MD, VD, R>;
+}
+export type ActionDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = ActionApiDefinition<MD, VD> | ActionHandlerDefinition<MD, VD, unknown>;
+export type ActionDefinitions<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Record<string, ActionDefinition<MD, VD>>;
+export type StoreAction<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> = {
+    [K in keyof AD]: ActionCall;
 };
-export interface ActionHandleContext<M extends Model, V, ApiResponse = unknown> {
-    api: <T = ApiResponse>() => Promise<T>;
-    view: DeepReadonly<V>;
-    commit: ActionCommitter<M>;
-}
-export interface ActionHandleContextNoApi<M extends Model, V> {
-    view: DeepReadonly<V>;
-    commit: ActionCommitter<M>;
-}
-export type ActionHandleCallback<M extends Model, V, R = void, ApiResponse = unknown> = (context: ActionHandleContext<M, V, ApiResponse>) => Promise<R>;
-export type ActionHandleCallbackNoApi<M extends Model, V, R = void> = (context: ActionHandleContextNoApi<M, V>) => Promise<R>;
-export type ActionHandleResolver<R = void> = (...args: unknown[]) => Promise<R>;
-export interface ActionDefinition<M extends Model, V, R = void> {
-    api?: ActionApiDefinition<V>;
-    handle?: ActionHandleCallback<M, V, R, unknown> | ActionHandleCallbackNoApi<M, V, R>;
-    commit?: {
-        model: keyof M;
-        mode: ActionOneMode | ActionManyMode;
-        value?: unknown;
-        options?: MutationsOneOptions | MutationsManyOptions;
-    };
-    logger?: ConsolaInstance;
-}
-export type ActionDefinitions<M extends Model, V> = Record<string, ActionDefinition<M, V, unknown>>;
-export interface ActionCommitMethod<M extends Model, V, R> {
-    <K extends keyof M, Mode extends ActionOneMode>(model: K, mode: Mode, ...args: Mode extends ActionOneMode.RESET ? [] : [value?: ActionCommitValue<M, K, Mode> | typeof AUTO, options?: MutationsOneOptions]): ActionCommitChain<M, V, R>;
-    <K extends keyof M, Mode extends ActionManyMode>(model: K, mode: Mode, ...args: Mode extends ActionManyMode.RESET ? [] : [value?: ActionCommitValue<M, K, Mode> | typeof AUTO, options?: MutationsManyOptions]): ActionCommitChain<M, V, R>;
-}
-export interface ActionApiChain<M extends Model, V, ApiResponse> {
-    handle<R>(callback: ActionHandleCallback<M, V, R, ApiResponse>): ActionHandleChain<M, V, R>;
-    commit: ActionCommitMethod<M, V, ApiResponse>;
-    readonly [DEFINITION]: ActionDefinition<M, V, ApiResponse>;
-}
-export interface ActionHandleChain<M extends Model, V, R> {
-    commit: ActionCommitMethod<M, V, R>;
-    readonly [DEFINITION]: ActionDefinition<M, V, R>;
-}
-export interface ActionCommitChain<M extends Model, V, R> {
-    readonly [DEFINITION]: ActionDefinition<M, V, R>;
-}
-export type ActionApiShortcutDefinition<V> = Omit<ActionApiDefinition<V>, "method">;
-export interface ActionApiFactory<M extends Model, V> {
-    <A>(definition: ActionApiDefinition<V>): ActionApiChain<M, V, A>;
-    get<A>(definition: ActionApiShortcutDefinition<V>): ActionApiChain<M, V, A>;
-    head<A>(definition: ActionApiShortcutDefinition<V>): ActionApiChain<M, V, A>;
-    post<A>(definition: ActionApiShortcutDefinition<V>): ActionApiChain<M, V, A>;
-    put<A>(definition: ActionApiShortcutDefinition<V>): ActionApiChain<M, V, A>;
-    patch<A>(definition: ActionApiShortcutDefinition<V>): ActionApiChain<M, V, A>;
-    delete<A>(definition: ActionApiShortcutDefinition<V>): ActionApiChain<M, V, A>;
-}
-export interface ActionFactory<M extends Model, V> {
-    api: ActionApiFactory<M, V>;
-    handle<R>(callback: ActionHandleCallbackNoApi<M, V, R>): ActionHandleChain<M, V, R>;
-    commit: ActionCommitMethod<M, V, void>;
-}
-export interface ActionCallBind {
+export interface ActionApiFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
+    (request: ActionApiRequest<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
+    get(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
+    head(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
+    post(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
+    put(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
+    patch(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
+    delete(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
+}
+export interface ActionHandlerFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
+    <R>(callback: ActionHandlerCallback<MD, VD, R>): ActionHandlerDefinition<MD, VD, R>;
+}
+export interface ActionFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
+    api: ActionApiFactory<MD, VD>;
+    handler: ActionHandlerFactory<MD, VD>;
+}
+export interface ActionCallBindOptions {
     status?: Ref<ActionStatus>;
-    error?: Ref<ActionError | null>;
+    error?: Ref<Error | null>;
 }
-export interface ActionCallCommit {
-    mode?: ActionOneMode | ActionManyMode;
+export interface ActionCallCommitOptions {
+    mode?: ModelOneMode | ModelManyMode;
 }
-export interface ActionCallPayload<V, T = unknown, R = T> {
-    headers?: Record<string, string> | ((view: DeepReadonly<V>) => Record<string, string>);
-    query?: Record<string, unknown> | ((view: DeepReadonly<V>) => Record<string, unknown>);
-    body?: unknown | ((view: DeepReadonly<V>) => unknown);
+export interface ActionResolvedApi {
+    url: string;
+    method: ActionApiMethod;
+    headers: Record<string, string>;
+    query: Record<string, unknown>;
+    body?: Record<string, unknown> | BodyInit | null;
+    timeout?: number;
+    signal: AbortSignal;
+}
+export interface ActionCallTransformerOptions {
+    request?: (api: ActionResolvedApi) => ActionResolvedApi;
+    response?: (data: unknown) => unknown;
+}
+export interface ActionCallOptions {
+    params?: Record<string, string>;
+    headers?: Record<string, string>;
+    query?: Record<string, unknown>;
+    body?: unknown;
     timeout?: number;
     signal?: AbortSignal;
-    transformer?: (response: T) => R;
+    transformer?: ActionCallTransformerOptions;
     concurrent?: ActionConcurrent;
-    bind?: ActionCallBind;
-    commit?: ActionCallCommit;
+    bind?: ActionCallBindOptions;
+    commit?: ActionCallCommitOptions;
 }
-export interface Action<V, T = void> {
-    (payload?: ActionCallPayload<V, T>): Promise<T>;
-    <R>(payload: ActionCallPayload<V, T, R>): Promise<R>;
-    readonly loading: ComputedRef<boolean>;
+export interface ActionCall<T = void> {
+    (options?: ActionCallOptions): Promise<T>;
+    readonly error: Readonly<Ref<Error | null>>;
     readonly status: Readonly<Ref<ActionStatus>>;
-    readonly error: Readonly<Ref<ActionError | null>>;
-    readonly data: DeepReadonly<T> | null;
+    readonly loading: ComputedRef<boolean>;
     reset: () => void;
 }

package/dist/runtime/core/types/action.js

@@ -1,19 +1,3 @@
-export const DEFINITION = Symbol("definition");
-export const AUTO = Symbol("auto");
-export var ActionOneMode = /* @__PURE__ */ ((ActionOneMode2) => {
-  ActionOneMode2["SET"] = "set";
-  ActionOneMode2["RESET"] = "reset";
-  ActionOneMode2["PATCH"] = "patch";
-  return ActionOneMode2;
-})(ActionOneMode || {});
-export var ActionManyMode = /* @__PURE__ */ ((ActionManyMode2) => {
-  ActionManyMode2["SET"] = "set";
-  ActionManyMode2["RESET"] = "reset";
-  ActionManyMode2["PATCH"] = "patch";
-  ActionManyMode2["REMOVE"] = "remove";
-  ActionManyMode2["ADD"] = "add";
-  return ActionManyMode2;
-})(ActionManyMode || {});
 export var ActionStatus = /* @__PURE__ */ ((ActionStatus2) => {
   ActionStatus2["IDLE"] = "idle";
   ActionStatus2["PENDING"] = "pending";

package/dist/runtime/core/types/base.d.ts

@@ -0,0 +1,6 @@
+import type { ConsolaInstance } from "consola";
+export interface BaseDefinition {
+    readonly key: string;
+    logger?: ConsolaInstance;
+    setKey(key: string): void;
+}

package/dist/runtime/core/types/model.d.ts

@@ -1,4 +1,4 @@
-import type { ConsolaInstance } from "consola";
+import type { BaseDefinition } from "./base.js";
 import type { Shape, ShapeType } from "./shape.js";
 export interface RuntimeModelConfig {
     identifier?: string;
@@ -7,64 +7,79 @@ export declare enum ModelKind {
     OBJECT = "object",
     ARRAY = "array"
 }
-export interface ModelOneOptions<S extends Shape> {
+export declare enum ModelOneMode {
+    SET = "set",
+    RESET = "reset",
+    PATCH = "patch"
+}
+export declare enum ModelManyMode {
+    SET = "set",
+    RESET = "reset",
+    PATCH = "patch",
+    REMOVE = "remove",
+    ADD = "add"
+}
+export interface ModelOneDefinitionOptions<S extends Shape> {
     identifier?: keyof S;
     default?: S;
 }
-export interface ModelManyOptions<S extends Shape> {
+export interface ModelManyDefinitionOptions<S extends Shape> {
     identifier?: keyof S;
     default?: S[];
 }
-export interface ModelOneDefinition<S extends Shape> {
+export interface ModelOneDefinition<S extends Shape> extends BaseDefinition {
     shape: ShapeType<S>;
     kind: ModelKind.OBJECT;
-    options?: ModelOneOptions<S>;
-    logger?: ConsolaInstance;
+    options?: ModelOneDefinitionOptions<S>;
 }
-export interface ModelManyDefinition<S extends Shape> {
+export interface ModelManyDefinition<S extends Shape> extends BaseDefinition {
     shape: ShapeType<S>;
     kind: ModelKind.ARRAY;
-    options?: ModelManyOptions<S>;
-    logger?: ConsolaInstance;
+    options?: ModelManyDefinitionOptions<S>;
 }
 export type ModelDefinition<S extends Shape> = ModelOneDefinition<S> | ModelManyDefinition<S>;
-export type Model = Record<string, ModelDefinition<any>>;
-export type ModelInstance<M extends Model, K extends keyof M> = M[K] extends ModelOneDefinition<infer S> ? S | null : M[K] extends ModelManyDefinition<infer S> ? S[] : never;
-export type ModelShape<M extends Model, K extends keyof M> = M[K] extends ModelDefinition<infer S> ? S : never;
-export type ModelOneKey<M extends Model> = {
-    [K in keyof M]: M[K] extends ModelOneDefinition<infer _S> ? K : never;
-}[keyof M];
-export type ModelManyKey<M extends Model> = {
-    [K in keyof M]: M[K] extends ModelManyDefinition<infer _S> ? K : never;
-}[keyof M];
-export type ModelStateOf<M extends Model> = {
-    [K in keyof M]: ModelInstance<M, K>;
+export type ModelDefinitions = Record<string, ModelDefinition<any>>;
+export type ModelDefinitionInfer<MD extends ModelDefinitions, K extends keyof MD> = MD[K] extends ModelOneDefinition<infer S> ? S | null : MD[K] extends ModelManyDefinition<infer S> ? S[] : never;
+export type ModelDefinitionInferTuple<MD extends ModelDefinitions, K extends readonly (keyof MD)[]> = {
+    [I in keyof K]: K[I] extends keyof MD ? ModelDefinitionInfer<MD, K[I]> : never;
+};
+export type ModelDefinitionsInfer<MD extends ModelDefinitions> = {
+    [K in keyof MD]: ModelDefinitionInfer<MD, K>;
 };
 export interface ModelFactory {
-    one<S extends Shape>(shape: ShapeType<S>, options?: ModelOneOptions<S>): ModelOneDefinition<S>;
-    many<S extends Shape>(shape: ShapeType<S>, options?: ModelManyOptions<S>): ModelManyDefinition<S>;
+    one<S extends Shape>(shape: ShapeType<S>, options?: ModelOneDefinitionOptions<S>): ModelOneDefinition<S>;
+    many<S extends Shape>(shape: ShapeType<S>, options?: ModelManyDefinitionOptions<S>): ModelManyDefinition<S>;
 }
-export interface MutationsOneOptions {
+export interface ModelOneCommitOptions {
     deep?: boolean;
 }
-export interface MutationsManyOptions {
+export interface ModelManyCommitOptions {
     by?: string;
     prepend?: boolean;
     unique?: boolean;
     deep?: boolean;
 }
-export interface MutationsOne<S extends Shape> {
+export interface ModelOneCommit<S extends Shape> {
     set: (value: S) => void;
     reset: () => void;
-    patch: (value: Partial<S>, options?: MutationsOneOptions) => void;
+    patch: (value: Partial<S>, options?: ModelOneCommitOptions) => void;
 }
-export interface MutationsMany<S extends Shape> {
+export interface ModelManyCommit<S extends Shape> {
     set: (value: S[]) => void;
     reset: () => void;
-    patch: (value: Partial<S> | Partial<S>[], options?: MutationsManyOptions) => void;
-    remove: (value: S | S[], options?: MutationsManyOptions) => void;
-    add: (value: S | S[], options?: MutationsManyOptions) => void;
+    patch: (value: Partial<S> | Partial<S>[], options?: ModelManyCommitOptions) => void;
+    remove: (value: S | S[], options?: ModelManyCommitOptions) => void;
+    add: (value: S | S[], options?: ModelManyCommitOptions) => void;
 }
-export type Mutations<M extends Model> = {
-    [K in keyof M]: M[K] extends ModelOneDefinition<infer S> ? MutationsOne<S> : M[K] extends ModelManyDefinition<infer S> ? MutationsMany<S> : never;
+export type ModelOneCall<S extends Shape> = ModelOneCommit<S> & {
+    commit(mode: string, value?: unknown, options?: unknown): void;
+    aliases(): Record<string, string>;
+};
+export type ModelManyCall<S extends Shape> = ModelManyCommit<S> & {
+    commit(mode: string, value?: unknown, options?: unknown): void;
+    aliases(): Record<string, string>;
+};
+export type ModelCall<S extends Shape> = ModelOneCall<S> | ModelManyCall<S>;
+export type StoreModel<MD extends ModelDefinitions> = {
+    [K in keyof MD]: MD[K] extends ModelOneDefinition<infer S> ? ModelOneCall<S> : MD[K] extends ModelManyDefinition<infer S> ? ModelManyCall<S> : never;
 };

package/dist/runtime/core/types/model.js

@@ -3,3 +3,17 @@ export var ModelKind = /* @__PURE__ */ ((ModelKind2) => {
   ModelKind2["ARRAY"] = "array";
   return ModelKind2;
 })(ModelKind || {});
+export var ModelOneMode = /* @__PURE__ */ ((ModelOneMode2) => {
+  ModelOneMode2["SET"] = "set";
+  ModelOneMode2["RESET"] = "reset";
+  ModelOneMode2["PATCH"] = "patch";
+  return ModelOneMode2;
+})(ModelOneMode || {});
+export var ModelManyMode = /* @__PURE__ */ ((ModelManyMode2) => {
+  ModelManyMode2["SET"] = "set";
+  ModelManyMode2["RESET"] = "reset";
+  ModelManyMode2["PATCH"] = "patch";
+  ModelManyMode2["REMOVE"] = "remove";
+  ModelManyMode2["ADD"] = "add";
+  return ModelManyMode2;
+})(ModelManyMode || {});

package/dist/runtime/core/types/shape.d.ts

@@ -1,12 +1,37 @@
 import type { z } from "zod";
-export type ShapeDefinition = z.ZodObject<z.ZodRawShape>;
+export type Shape = Record<string, unknown>;
+export type ShapeRawDefinition = z.ZodRawShape;
+export type ShapeDefinition = z.ZodObject<ShapeRawDefinition>;
 export type ShapeType<S> = z.ZodType<S>;
 export type ShapeInfer<T extends z.ZodType<any>> = z.infer<T>;
-export type Shape = Record<string, unknown>;
-export interface ShapeMeta {
-    identifier?: string;
+export type ShapeCall<T extends ShapeRawDefinition> = z.ZodObject<T> & {
+    defaults: (overrides?: Partial<z.infer<z.ZodObject<T>>>) => z.infer<z.ZodObject<T>>;
+};
+export interface ShapeResolved<T extends ShapeDefinition = ShapeDefinition> {
+    identifier?: keyof T["shape"] & string;
     defaults: Record<string, unknown>;
-    fields: string[];
+    fields: (keyof T["shape"] & string)[];
+    aliases: Record<string, string>;
+}
+export interface ShapeFieldDefinition {
+    meta?: {
+        identifier?: boolean;
+        alias?: string;
+    };
+    defaultValue?: unknown;
+}
+export interface ZodFieldDefinition {
+    type?: string;
+    shape?: Record<string, z.ZodType>;
+    element?: z.ZodType;
+    items?: z.ZodType[];
+    entries?: Record<string, string | number>;
+    values?: unknown[];
+    options?: z.ZodType[];
+    innerType?: z.ZodType;
+    defaultValue?: unknown;
+    keyType?: z.ZodType;
+    valueType?: z.ZodType;
 }
 export interface ShapeFactory {
     string: typeof z.string;

package/dist/runtime/core/types/store.d.ts

@@ -0,0 +1,14 @@
+import type { ModelDefinitions, ModelFactory, StoreModel } from "./model.js";
+import type { ViewDefinitions, ViewFactory, StoreView } from "./view.js";
+import type { ActionDefinition, ActionDefinitions, ActionFactory, StoreAction } from "./action.js";
+export interface StoreConfig<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, _AD extends ActionDefinitions<MD, VD>> {
+    name: string;
+    model: (factory: ModelFactory) => MD;
+    view: (factory: ViewFactory<MD>) => VD;
+    action: (factory: ActionFactory<MD, VD>) => Record<string, ActionDefinition<MD, VD>>;
+}
+export interface Store<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
+    model: StoreModel<MD>;
+    view: StoreView<MD, VD>;
+    action: StoreAction<MD, VD, AD>;
+}

package/dist/runtime/core/types/view.d.ts

@@ -1,29 +1,40 @@
-import type { ConsolaInstance } from "consola";
-import type { Model, ModelInstance } from "./model.js";
+import type { ComputedRef } from "vue";
+import type { BaseDefinition } from "./base.js";
+import type { ModelDefinitions, ModelDefinitionInfer, ModelDefinitionInferTuple } from "./model.js";
+export declare enum ViewClone {
+    SHALLOW = "shallow",
+    DEEP = "deep"
+}
 export interface RuntimeViewConfig {
+    clone?: ViewClone;
 }
-export type ViewFromResolver<M extends Model, K extends keyof M, R> = (model: ModelInstance<M, K>) => R;
-export type ModelInstanceTuple<M extends Model, K extends readonly (keyof M)[]> = {
-    [I in keyof K]: K[I] extends keyof M ? ModelInstance<M, K[I]> : never;
-};
-export type ViewMergeResolver<M extends Model, K extends readonly (keyof M)[], R> = (...values: [...ModelInstanceTuple<M, K>]) => R;
-export interface ViewFromDefinition<M extends Model, K extends keyof M, R = ModelInstance<M, K>> {
-    sources: readonly [K];
-    resolver?: ViewFromResolver<M, K, R>;
-    logger?: ConsolaInstance;
+export interface ViewDefinitionOptions {
+    clone?: ViewClone;
 }
-export interface ViewMergeDefinition<M extends Model, K extends readonly (keyof M)[], R> {
-    sources: K;
-    resolver: ViewMergeResolver<M, K, R>;
-    logger?: ConsolaInstance;
+export type ViewFromDefinitionResolver<MD extends ModelDefinitions, K extends keyof MD, R> = (model: ModelDefinitionInfer<MD, K>) => R;
+export type ViewMergeDefinitionResolver<MD extends ModelDefinitions, K extends readonly (keyof MD)[], R> = (...values: [...ModelDefinitionInferTuple<MD, K>]) => R;
+export interface ViewFromDefinition<MD extends ModelDefinitions, K extends keyof MD, R = ModelDefinitionInfer<MD, K>> extends BaseDefinition {
+    model: readonly [K];
+    resolver?: ViewFromDefinitionResolver<MD, K, R>;
+    options?: ViewDefinitionOptions;
 }
-export type ViewDefinition<M extends Model> = ViewFromDefinition<M, keyof M, unknown> | ViewMergeDefinition<M, readonly (keyof M)[], unknown>;
-export type ViewDefinitions<M extends Model> = Record<string, ViewDefinition<M>>;
-export type ViewResult<M extends Model, VD extends ViewDefinition<M>> = VD extends ViewFromDefinition<M, infer _K, infer R> ? R : VD extends ViewMergeDefinition<M, infer _K, infer R> ? R : never;
-export interface ViewFactory<M extends Model> {
-    from<K extends keyof M>(source: K): ViewFromDefinition<M, K, ModelInstance<M, K>>;
-    from<K extends keyof M, R>(source: K, resolver: ViewFromResolver<M, K, R>): ViewFromDefinition<M, K, R>;
-    merge<K1 extends keyof M, K2 extends keyof M, R>(sources: readonly [K1, K2], resolver: (v1: ModelInstance<M, K1>, v2: ModelInstance<M, K2>) => R): ViewMergeDefinition<M, readonly [K1, K2], R>;
-    merge<K1 extends keyof M, K2 extends keyof M, K3 extends keyof M, R>(sources: readonly [K1, K2, K3], resolver: (v1: ModelInstance<M, K1>, v2: ModelInstance<M, K2>, v3: ModelInstance<M, K3>) => R): ViewMergeDefinition<M, readonly [K1, K2, K3], R>;
-    merge<K extends readonly (keyof M)[], R>(sources: K, resolver: ViewMergeResolver<M, K, R>): ViewMergeDefinition<M, K, R>;
+export interface ViewMergeDefinition<MD extends ModelDefinitions, K extends readonly (keyof MD)[], R> extends BaseDefinition {
+    models: K;
+    resolver: ViewMergeDefinitionResolver<MD, K, R>;
+    options?: ViewDefinitionOptions;
 }
+export type ViewDefinition<MD extends ModelDefinitions> = ViewFromDefinition<MD, keyof MD, unknown> | ViewMergeDefinition<MD, readonly (keyof MD)[], unknown>;
+export type ViewDefinitions<MD extends ModelDefinitions> = Record<string, ViewDefinition<MD>>;
+export type ViewDefinitionInfer<MD extends ModelDefinitions, VD extends ViewDefinition<MD>> = VD extends ViewFromDefinition<MD, infer _K, infer R> ? R : VD extends ViewMergeDefinition<MD, infer _K, infer R> ? R : never;
+export interface ViewFactory<MD extends ModelDefinitions> {
+    from<K extends keyof MD>(model: K): ViewFromDefinition<MD, K, ModelDefinitionInfer<MD, K>>;
+    from<K extends keyof MD, R>(model: K, resolver: ViewFromDefinitionResolver<MD, K, R>, options?: ViewDefinitionOptions): ViewFromDefinition<MD, K, R>;
+    merge<MK1 extends keyof MD, MK2 extends keyof MD, R>(models: readonly [MK1, MK2], resolver: (mv1: ModelDefinitionInfer<MD, MK1>, mv2: ModelDefinitionInfer<MD, MK2>) => R, options?: ViewDefinitionOptions): ViewMergeDefinition<MD, readonly [MK1, MK2], R>;
+    merge<MK1 extends keyof MD, MK2 extends keyof MD, MK3 extends keyof MD, R>(models: readonly [MK1, MK2, MK3], resolver: (mv1: ModelDefinitionInfer<MD, MK1>, mv2: ModelDefinitionInfer<MD, MK2>, mv3: ModelDefinitionInfer<MD, MK3>) => R, options?: ViewDefinitionOptions): ViewMergeDefinition<MD, readonly [MK1, MK2, MK3], R>;
+    merge<MK1 extends keyof MD, MK2 extends keyof MD, MK3 extends keyof MD, MK4 extends keyof MD, R>(models: readonly [MK1, MK2, MK3, MK4], resolver: (mv1: ModelDefinitionInfer<MD, MK1>, mv2: ModelDefinitionInfer<MD, MK2>, mv3: ModelDefinitionInfer<MD, MK3>, mv4: ModelDefinitionInfer<MD, MK4>) => R, options?: ViewDefinitionOptions): ViewMergeDefinition<MD, readonly [MK1, MK2, MK3, MK4], R>;
+    merge<MK1 extends keyof MD, MK2 extends keyof MD, MK3 extends keyof MD, MK4 extends keyof MD, MK5 extends keyof MD, R>(models: readonly [MK1, MK2, MK3, MK4, MK5], resolver: (mv1: ModelDefinitionInfer<MD, MK1>, mv2: ModelDefinitionInfer<MD, MK2>, mv3: ModelDefinitionInfer<MD, MK3>, mv4: ModelDefinitionInfer<MD, MK4>, mv5: ModelDefinitionInfer<MD, MK5>) => R, options?: ViewDefinitionOptions): ViewMergeDefinition<MD, readonly [MK1, MK2, MK3, MK4, MK5], R>;
+}
+export type ViewCall<R = unknown> = ComputedRef<R>;
+export type StoreView<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = {
+    readonly [K in keyof VD]: ViewCall<ViewDefinitionInfer<MD, VD[K]>>;
+};

package/dist/runtime/core/types/view.js

@@ -0,0 +1,5 @@
+export var ViewClone = /* @__PURE__ */ ((ViewClone2) => {
+  ViewClone2["SHALLOW"] = "shallow";
+  ViewClone2["DEEP"] = "deep";
+  return ViewClone2;
+})(ViewClone || {});