@diphyx/harlemify 5.2.0 → 5.3.0

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0 || >=4.0.0"
   },
-  "version": "5.2.0",
+  "version": "5.3.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

package/dist/runtime/composables/action.d.ts

@@ -1,10 +1,10 @@
 import { type ComputedRef, type Ref } from "vue";
-import { ActionStatus, type ActionCall, type ActionCallOptions } from "../core/types/action.js";
+import { ActionStatus, type ActionCall, type ActionApiCall, type ActionHandlerCall, type ActionCallOptions, type ActionApiCallOptions, type ActionHandlerCallOptions } from "../core/types/action.js";
 export interface UseStoreActionOptions {
     isolated?: boolean;
 }
-export type UseStoreAction<T> = {
-    execute: (options?: ActionCallOptions) => Promise<T>;
+export type UseStoreAction<T, O = ActionCallOptions> = {
+    execute: (options?: Omit<O, "bind">) => Promise<T>;
     error: Readonly<Ref<Error | null>>;
     status: Readonly<Ref<ActionStatus>>;
     loading: ComputedRef<boolean>;
@@ -14,4 +14,4 @@ export declare function useIsolatedActionError(): Ref<Error | null>;
 export declare function useIsolatedActionStatus(): Ref<ActionStatus>;
 export declare function useStoreAction<A extends Record<string, ActionCall<any>>, K extends keyof A & string, T = Awaited<ReturnType<A[K]>>>(store: {
     action: A;
-}, key: K, options?: UseStoreActionOptions): UseStoreAction<T>;
+}, key: K, options?: UseStoreActionOptions): UseStoreAction<T, A[K] extends ActionHandlerCall<infer P, any> ? ActionHandlerCallOptions<P> : A[K] extends ActionApiCall<any> ? ActionApiCallOptions : ActionCallOptions>;

package/dist/runtime/composables/model.d.ts

@@ -1,4 +1,4 @@
-import type { ModelCall, ModelOneCall, ModelManyCall, ModelOneCommit, ModelManyCommit, StoreModel, ModelDefinitions } from "../core/types/model.js";
+import type { ModelCall, ModelOneCall, ModelManyCall, ModelOneCommit, ModelManyListCommit, ModelManyRecordCommit, ModelManyCommit, StoreModel, ModelDefinitions } from "../core/types/model.js";
 export interface UseStoreModelOptions {
     debounce?: number;
     throttle?: number;
@@ -8,14 +8,14 @@ type UseStoreModelOne<C extends ModelOneCommit<any>> = {
     reset: C["reset"];
     patch: C["patch"];
 };
-type UseStoreModelMany<C extends ModelManyCommit<any>> = {
+type UseStoreModelMany<C extends ModelManyListCommit<any, any> | ModelManyRecordCommit<any>> = {
     set: C["set"];
     reset: C["reset"];
     patch: C["patch"];
     add: C["add"];
     remove: C["remove"];
 };
-export type UseStoreModel<M extends ModelCall<any> = ModelCall<any>> = M extends ModelManyCall<infer S> ? UseStoreModelMany<ModelManyCommit<S>> : M extends ModelOneCall<infer S> ? UseStoreModelOne<ModelOneCommit<S>> : never;
+export type UseStoreModel<M extends ModelCall<any> = ModelCall<any>> = M extends ModelManyCall<infer S, infer I, infer T> ? UseStoreModelMany<ModelManyCommit<S, I, T>> : M extends ModelOneCall<infer S> ? UseStoreModelOne<ModelOneCommit<S>> : never;
 export declare function useStoreModel<M extends StoreModel<ModelDefinitions>, K extends keyof M & string>(store: {
     model: M;
 }, key: K, options?: UseStoreModelOptions): UseStoreModel<M[K]>;

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

@@ -1,12 +1,12 @@
 import { wrapBaseDefinition } from "../utils/base.js";
 import {
-  ModelKind
+  ModelType
 } from "../types/model.js";
 export function createModelFactory(config, logger) {
   function one(shape, options) {
     return wrapBaseDefinition({
       shape,
-      kind: ModelKind.OBJECT,
+      type: ModelType.ONE,
       options: {
         identifier: config?.identifier,
         ...options
@@ -17,7 +17,7 @@ export function createModelFactory(config, logger) {
   function many(shape, options) {
     return wrapBaseDefinition({
       shape,
-      kind: ModelKind.ARRAY,
+      type: ModelType.MANY,
       options: {
         identifier: config?.identifier,
         ...options

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

@@ -1,6 +1,6 @@
 import type { ComputedRef, DeepReadonly, MaybeRefOrGetter, Ref } from "vue";
 import type { BaseDefinition } from "./base.js";
-import type { ModelDefinitions, ModelOneCommitOptions, ModelManyCommitOptions, StoreModel } from "./model.js";
+import type { ModelDefinitions, ModelDefinitionInfer, ModelOneCommitOptions, ModelManyCommitOptions, StoreModel } from "./model.js";
 import { ModelOneMode, ModelManyMode } from "./model.js";
 import type { ViewDefinitions, StoreView } from "./view.js";
 export interface RuntimeActionConfig {
@@ -22,6 +22,10 @@ export declare enum ActionConcurrent {
     CANCEL = "cancel",
     ALLOW = "allow"
 }
+export declare enum ActionType {
+    API = "api",
+    HANDLER = "handler"
+}
 export declare enum ActionApiMethod {
     GET = "GET",
     HEAD = "HEAD",
@@ -42,42 +46,49 @@ export interface ActionApiRequest<MD extends ModelDefinitions, VD extends ViewDe
     concurrent?: ActionConcurrent;
 }
 export type ActionApiRequestShortcut<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Omit<ActionApiRequest<MD, VD>, "method">;
-export interface ActionApiCommit<MD extends ModelDefinitions> {
-    model: keyof MD;
+export interface ActionApiCommit<MD extends ModelDefinitions, K extends keyof MD = keyof MD> {
+    model: K;
     mode: ModelOneMode | ModelManyMode;
     value?: (data: unknown) => unknown;
     options?: ModelOneCommitOptions | ModelManyCommitOptions;
 }
-export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> extends BaseDefinition {
+export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, K extends keyof MD = keyof MD> extends BaseDefinition {
     request: ActionApiRequest<MD, VD>;
-    commit?: ActionApiCommit<MD>;
+    commit?: ActionApiCommit<MD, K>;
 }
-export interface ActionHandlerOptions {
-    payload?: unknown;
+export interface ActionHandlerOptions<P = unknown> {
+    payload?: P;
     concurrent?: ActionConcurrent;
 }
-export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> = (context: {
+export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, P = unknown, R = void> = (context: {
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
-    payload: unknown;
+    payload: P;
 }) => Promise<R>;
-export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> extends BaseDefinition {
-    callback: ActionHandlerCallback<MD, VD, R>;
-    options?: ActionHandlerOptions;
+export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, P = unknown, R = void> extends BaseDefinition {
+    callback: ActionHandlerCallback<MD, VD, P, R>;
+    options?: ActionHandlerOptions<P>;
 }
-export type ActionDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = ActionApiDefinition<MD, VD> | ActionHandlerDefinition<MD, VD, unknown>;
+export type ActionDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = ActionApiDefinition<MD, VD> | ActionHandlerDefinition<MD, VD, any, any>;
 export type ActionDefinitions<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Record<string, ActionDefinition<MD, VD>>;
 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>;
+    <K extends keyof MD>(request: ActionApiRequest<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    (request: ActionApiRequest<MD, VD>): ActionApiDefinition<MD, VD>;
+    get<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    get(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    head<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    head(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    post<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    post(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    put<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    put(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    patch<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    patch(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    delete<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    delete(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
 }
 export interface ActionHandlerFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
-    <R>(callback: ActionHandlerCallback<MD, VD, R>, options?: ActionHandlerOptions): ActionHandlerDefinition<MD, VD, R>;
+    <P = unknown, R = void>(callback: ActionHandlerCallback<MD, VD, P, R>, options?: ActionHandlerOptions<P>): ActionHandlerDefinition<MD, VD, P, R>;
 }
 export interface ActionFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
     api: ActionApiFactory<MD, VD>;
@@ -117,13 +128,13 @@ export interface ActionApiCallOptions extends ActionCallBaseOptions {
     transformer?: ActionCallTransformerOptions;
     commit?: ActionCallCommitOptions;
 }
-export interface ActionResolvedHandler<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
+export interface ActionResolvedHandler<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, P = unknown> {
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
-    payload: unknown;
+    payload: P;
 }
-export interface ActionHandlerCallOptions extends ActionCallBaseOptions {
-    payload?: unknown;
+export interface ActionHandlerCallOptions<P = unknown> extends ActionCallBaseOptions {
+    payload?: P;
 }
 export type ActionCallOptions = ActionApiCallOptions | ActionHandlerCallOptions;
 export interface ActionCallBase {
@@ -133,12 +144,14 @@ export interface ActionCallBase {
     reset: () => void;
 }
 export interface ActionApiCall<T = void> extends ActionCallBase {
+    readonly actionType: ActionType.API;
     (options?: ActionApiCallOptions): Promise<T>;
 }
-export interface ActionHandlerCall<T = void> extends ActionCallBase {
-    (options?: ActionHandlerCallOptions): Promise<T>;
+export interface ActionHandlerCall<P = unknown, T = void> extends ActionCallBase {
+    readonly actionType: ActionType.HANDLER;
+    (options?: ActionHandlerCallOptions<P>): Promise<T>;
 }
-export type ActionCall<T = void> = ActionApiCall<T> | ActionHandlerCall<T>;
+export type ActionCall<T = void> = ActionApiCall<T> | ActionHandlerCall<any, T>;
 export type StoreAction<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> = {
-    [K in keyof AD]: AD[K] extends ActionApiDefinition<MD, VD> ? ActionApiCall : AD[K] extends ActionHandlerDefinition<MD, VD, infer R> ? ActionHandlerCall<R> : never;
+    [K in keyof AD]: AD[K] extends ActionApiDefinition<MD, VD, infer MK> ? MK extends keyof MD ? ActionApiCall<ModelDefinitionInfer<MD, MK>> : ActionApiCall : AD[K] extends ActionHandlerDefinition<MD, VD, infer P, infer R> ? ActionHandlerCall<P, R> : never;
 };

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

@@ -12,6 +12,11 @@ export var ActionConcurrent = /* @__PURE__ */ ((ActionConcurrent2) => {
   ActionConcurrent2["ALLOW"] = "allow";
   return ActionConcurrent2;
 })(ActionConcurrent || {});
+export var ActionType = /* @__PURE__ */ ((ActionType2) => {
+  ActionType2["API"] = "api";
+  ActionType2["HANDLER"] = "handler";
+  return ActionType2;
+})(ActionType || {});
 export var ActionApiMethod = /* @__PURE__ */ ((ActionApiMethod2) => {
   ActionApiMethod2["GET"] = "GET";
   ActionApiMethod2["HEAD"] = "HEAD";

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

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

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

@@ -3,9 +3,13 @@ import type { Shape, ShapeType } from "./shape.js";
 export interface RuntimeModelConfig {
     identifier?: string;
 }
-export declare enum ModelKind {
-    OBJECT = "object",
-    ARRAY = "array"
+export declare enum ModelType {
+    ONE = "one",
+    MANY = "many"
+}
+export declare enum ModelManyKind {
+    LIST = "list",
+    RECORD = "record"
 }
 export declare enum ModelOneMode {
     SET = "set",
@@ -19,27 +23,33 @@ export declare enum ModelManyMode {
     REMOVE = "remove",
     ADD = "add"
 }
+export type ModelDefaultIdentifier<S extends Shape> = "id" extends keyof S ? "id" : keyof S;
+export type AtLeastOne<S extends Shape> = {
+    [K in keyof S]: Pick<S, K>;
+}[keyof S];
 export interface ModelOneDefinitionOptions<S extends Shape> {
     identifier?: keyof S;
     default?: S;
 }
-export interface ModelManyDefinitionOptions<S extends Shape> {
-    identifier?: keyof S;
-    default?: S[];
-}
+export type ModelManyDefinitionOptions<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> = {
+    kind?: T;
+    default?: [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>;
+} & ([T] extends [ModelManyKind.LIST] ? {
+    identifier?: I;
+} : {});
 export interface ModelOneDefinition<S extends Shape> extends BaseDefinition {
     shape: ShapeType<S>;
-    kind: ModelKind.OBJECT;
+    type: ModelType.ONE;
     options?: ModelOneDefinitionOptions<S>;
 }
-export interface ModelManyDefinition<S extends Shape> extends BaseDefinition {
+export interface ModelManyDefinition<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> extends BaseDefinition {
     shape: ShapeType<S>;
-    kind: ModelKind.ARRAY;
-    options?: ModelManyDefinitionOptions<S>;
+    type: ModelType.MANY;
+    options?: ModelManyDefinitionOptions<S, I, T>;
 }
-export type ModelDefinition<S extends Shape> = ModelOneDefinition<S> | ModelManyDefinition<S>;
+export type ModelDefinition<S extends Shape> = ModelOneDefinition<S> | ModelManyDefinition<S, any, any>;
 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 ModelDefinitionInfer<MD extends ModelDefinitions, K extends keyof MD> = MD[K] extends ModelOneDefinition<infer S> ? S | null : MD[K] extends ModelManyDefinition<infer S, any, infer T> ? [T] extends [ModelManyKind.LIST] ? S[] : Record<string, 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;
 };
@@ -48,7 +58,7 @@ export type ModelDefinitionsInfer<MD extends ModelDefinitions> = {
 };
 export interface ModelFactory {
     one<S extends Shape>(shape: ShapeType<S>, options?: ModelOneDefinitionOptions<S>): ModelOneDefinition<S>;
-    many<S extends Shape>(shape: ShapeType<S>, options?: ModelManyDefinitionOptions<S>): ModelManyDefinition<S>;
+    many<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST>(shape: ShapeType<S>, options?: ModelManyDefinitionOptions<S, I, T>): ModelManyDefinition<S, I, T>;
 }
 export interface ModelOneCommitOptions {
     deep?: boolean;
@@ -64,22 +74,30 @@ export interface ModelOneCommit<S extends Shape> {
     reset: () => void;
     patch: (value: Partial<S>, options?: ModelOneCommitOptions) => void;
 }
-export interface ModelManyCommit<S extends Shape> {
+export interface ModelManyListCommit<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>> {
     set: (value: S[]) => void;
     reset: () => void;
     patch: (value: Partial<S> | Partial<S>[], options?: ModelManyCommitOptions) => void;
-    remove: (value: S | S[], options?: ModelManyCommitOptions) => void;
+    remove: (value: Pick<S, I> | Pick<S, I>[] | AtLeastOne<S> | AtLeastOne<S>[]) => void;
     add: (value: S | S[], options?: ModelManyCommitOptions) => void;
 }
+export interface ModelManyRecordCommit<S extends Shape> {
+    set: (value: Record<string, S[]>) => void;
+    reset: () => void;
+    patch: (value: Record<string, S[]>, options?: ModelOneCommitOptions) => void;
+    remove: (key: string) => void;
+    add: (key: string, value: S[]) => void;
+}
+export type ModelManyCommit<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> = [T] extends [ModelManyKind.LIST] ? ModelManyListCommit<S, I> : ModelManyRecordCommit<S>;
 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> & {
+export type ModelManyCall<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> = ModelManyCommit<S, I, T> & {
     commit(mode: string, value?: unknown, options?: unknown): void;
     aliases(): Record<string, string>;
 };
-export type ModelCall<S extends Shape> = ModelOneCall<S> | ModelManyCall<S>;
+export type ModelCall<S extends Shape> = ModelOneCall<S> | ModelManyCall<S, any, any>;
 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;
+    [K in keyof MD]: MD[K] extends ModelOneDefinition<infer S> ? ModelOneCall<S> : MD[K] extends ModelManyDefinition<infer S, infer I, infer T> ? ModelManyCall<S, I, T> : never;
 };

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

@@ -1,8 +1,13 @@
-export var ModelKind = /* @__PURE__ */ ((ModelKind2) => {
-  ModelKind2["OBJECT"] = "object";
-  ModelKind2["ARRAY"] = "array";
-  return ModelKind2;
-})(ModelKind || {});
+export var ModelType = /* @__PURE__ */ ((ModelType2) => {
+  ModelType2["ONE"] = "one";
+  ModelType2["MANY"] = "many";
+  return ModelType2;
+})(ModelType || {});
+export var ModelManyKind = /* @__PURE__ */ ((ModelManyKind2) => {
+  ModelManyKind2["LIST"] = "list";
+  ModelManyKind2["RECORD"] = "record";
+  return ModelManyKind2;
+})(ModelManyKind || {});
 export var ModelOneMode = /* @__PURE__ */ ((ModelOneMode2) => {
   ModelOneMode2["SET"] = "set";
   ModelOneMode2["RESET"] = "reset";

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

@@ -2,6 +2,7 @@ import { defu } from "defu";
 import { ref, computed, readonly, toValue, nextTick } from "vue";
 import {
   ActionApiMethod,
+  ActionType,
   ActionStatus,
   ActionConcurrent
 } from "../types/action.js";
@@ -211,9 +212,10 @@ function executeCommit(definition, target, mode, data) {
   }
 }
 export function createAction(definition, model, view) {
+  const actionType = isApiDefinition(definition) ? ActionType.API : ActionType.HANDLER;
   definition.logger?.debug("Registering action", {
     action: definition.key,
-    type: isApiDefinition(definition) ? "api" : "handler"
+    type: actionType
   });
   let currentController = null;
   let abortController = null;
@@ -304,6 +306,7 @@ export function createAction(definition, model, view) {
     return currentController;
   }
   const action = Object.assign(execute, {
+    actionType,
     get error() {
       return readonly(globalError);
     },

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

@@ -1,7 +1,8 @@
 import type { BaseDefinition } from "../types/base.js";
-export declare function wrapBaseDefinition<T extends Omit<BaseDefinition, "key" | "setKey">>(definition: T): T & BaseDefinition;
+export declare function wrapBaseDefinition<T extends Omit<BaseDefinition, "key">>(definition: T): T & BaseDefinition;
 export declare function trimStart(value: string, char: string): string;
 export declare function trimEnd(value: string, char: string): string;
+export declare function ensureArray<T>(value: T | T[]): T[];
 export declare function isObject(value: unknown): value is object;
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 export declare function isEmptyRecord(record: Record<string, unknown> | undefined): record is undefined;

package/dist/runtime/core/utils/base.js

@@ -5,11 +5,7 @@ export function wrapBaseDefinition(definition) {
       get() {
         return key;
       },
-      enumerable: true,
-      configurable: true
-    },
-    setKey: {
-      value(value) {
+      set(value) {
         key = value;
       },
       enumerable: true,
@@ -23,6 +19,9 @@ export function trimStart(value, char) {
 export function trimEnd(value, char) {
   return value.replace(new RegExp(`${char}+$`), "");
 }
+export function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
 export function isObject(value) {
   return value != null && typeof value === "object";
 }

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

@@ -1,7 +1,9 @@
 import { defu } from "defu";
+import { ensureArray } from "./base.js";
 import { resolveShape } from "./shape.js";
 import {
-  ModelKind,
+  ModelType,
+  ModelManyKind,
   ModelOneMode,
   ModelManyMode
 } from "../types/model.js";
@@ -64,7 +66,7 @@ function createOneCommit(definition, source) {
     patch
   };
 }
-function createManyCommit(definition, shape, source) {
+function createManyListCommit(definition, shape, source) {
   const identifier = resolveIdentifier(definition, shape);
   const setOperation = source.mutation(`${definition.key}:set`, (state, value) => {
     state[definition.key] = value;
@@ -75,11 +77,11 @@ function createManyCommit(definition, shape, source) {
   const patchOperation = source.mutation(
     `${definition.key}:patch`,
     (state, payload) => {
-      const items = Array.isArray(payload.value) ? payload.value : [payload.value];
+      const items = ensureArray(payload.value);
       const by = payload.options?.by ?? identifier;
       state[definition.key] = state[definition.key].map((item) => {
-        const found = items.find((p) => {
-          return p[by] === item[by];
+        const found = items.find((partial) => {
+          return partial[by] === item[by];
         });
         if (!found) {
           return item;
@@ -96,23 +98,25 @@ function createManyCommit(definition, shape, source) {
   );
   const removeOperation = source.mutation(
     `${definition.key}:remove`,
-    (state, payload) => {
-      const items = Array.isArray(payload.value) ? payload.value : [payload.value];
-      const by = payload.options?.by ?? identifier;
-      const ids = new Set(
-        items.map((item) => {
-          return item[by];
-        })
-      );
+    (state, value) => {
+      const items = ensureArray(value);
       state[definition.key] = state[definition.key].filter((item) => {
-        return !ids.has(item[by]);
+        return !items.some((match) => {
+          let keys = Object.keys(match);
+          if (identifier in match) {
+            keys = [identifier];
+          }
+          return keys.every((key) => {
+            return item[key] === match[key];
+          });
+        });
       });
     }
   );
   const addOperation = source.mutation(
     `${definition.key}:add`,
     (state, payload) => {
-      let items = Array.isArray(payload.value) ? payload.value : [payload.value];
+      let items = ensureArray(payload.value);
       if (payload.options?.unique) {
         const by = payload.options.by ?? identifier;
         const existingIds = new Set(
@@ -155,15 +159,12 @@ function createManyCommit(definition, shape, source) {
       options
     });
   }
-  function remove(value, options) {
+  function remove(value) {
     definition.logger?.debug("Model mutation", {
       model: definition.key,
       mutation: "remove"
     });
-    removeOperation({
-      value,
-      options
-    });
+    removeOperation(value);
   }
   function add(value, options) {
     definition.logger?.debug("Model mutation", {
@@ -183,19 +184,112 @@ function createManyCommit(definition, shape, source) {
     add
   };
 }
+function createManyRecordCommit(definition, source) {
+  const setOperation = source.mutation(
+    `${definition.key}:set`,
+    (state, value) => {
+      state[definition.key] = value;
+    }
+  );
+  const resetOperation = source.mutation(`${definition.key}:reset`, (state) => {
+    state[definition.key] = definition.options?.default ?? {};
+  });
+  const patchOperation = source.mutation(
+    `${definition.key}:patch`,
+    (state, payload) => {
+      if (payload.options?.deep) {
+        state[definition.key] = defu(payload.value, state[definition.key]);
+        return;
+      }
+      state[definition.key] = {
+        ...state[definition.key],
+        ...payload.value
+      };
+    }
+  );
+  const removeOperation = source.mutation(`${definition.key}:remove`, (state, key) => {
+    const record = {};
+    for (const entry of Object.keys(state[definition.key])) {
+      if (entry !== key) {
+        record[entry] = state[definition.key][entry];
+      }
+    }
+    state[definition.key] = record;
+  });
+  const addOperation = source.mutation(
+    `${definition.key}:add`,
+    (state, payload) => {
+      state[definition.key] = {
+        ...state[definition.key],
+        [payload.key]: payload.value
+      };
+    }
+  );
+  function set(value) {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "set"
+    });
+    setOperation(value);
+  }
+  function reset() {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "reset"
+    });
+    resetOperation();
+  }
+  function patch(value, options) {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "patch"
+    });
+    patchOperation({ value, options });
+  }
+  function remove(key) {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "remove"
+    });
+    removeOperation(key);
+  }
+  function add(key, value) {
+    definition.logger?.debug("Model mutation", {
+      model: definition.key,
+      mutation: "add"
+    });
+    addOperation({ key, value });
+  }
+  return {
+    set,
+    reset,
+    patch,
+    remove,
+    add
+  };
+}
 function isOneDefinition(definition) {
-  return definition.kind === ModelKind.OBJECT;
+  return definition.type === ModelType.ONE;
+}
+function isManyRecordDefinition(definition) {
+  return definition.options?.kind === ModelManyKind.RECORD;
+}
+function resolveManyCommit(definition, shape, source) {
+  if (isManyRecordDefinition(definition)) {
+    return createManyRecordCommit(definition, source);
+  }
+  return createManyListCommit(definition, shape, source);
 }
 function resolveCommit(definition, shape, source) {
   if (isOneDefinition(definition)) {
     return createOneCommit(definition, source);
   }
-  return createManyCommit(definition, shape, source);
+  return resolveManyCommit(definition, shape, source);
 }
 export function createModel(definition, source) {
   definition.logger?.debug("Registering model", {
     model: definition.key,
-    kind: definition.kind
+    type: definition.type
   });
   const shape = resolveShape(definition.shape);
   const commit = resolveCommit(definition, shape, source);

package/dist/runtime/core/utils/store.js

@@ -1,18 +1,26 @@
 import { createModel } from "./model.js";
 import { createView } from "./view.js";
 import { createAction } from "./action.js";
-import { ModelKind } from "../types/model.js";
+import {
+  ModelType,
+  ModelManyKind
+} from "../types/model.js";
 export function createStoreState(modelDefinitions) {
   const output = {};
-  for (const [key, { options, kind }] of Object.entries(modelDefinitions)) {
-    output[key] = options?.default ?? (kind === ModelKind.OBJECT ? null : []);
+  for (const [key, { options, type }] of Object.entries(modelDefinitions)) {
+    if (type === ModelType.ONE) {
+      output[key] = options?.default ?? null;
+    } else {
+      const manyDefault = options?.kind === ModelManyKind.RECORD ? {} : [];
+      output[key] = options?.default ?? manyDefault;
+    }
   }
   return output;
 }
 export function createStoreModel(modelDefinitions, source) {
   const output = {};
   for (const [key, definition] of Object.entries(modelDefinitions)) {
-    definition.setKey(key);
+    definition.key = key;
     output[key] = createModel(definition, source);
   }
   return output;
@@ -20,7 +28,7 @@ export function createStoreModel(modelDefinitions, source) {
 export function createStoreView(viewDefinitions, source) {
   const output = {};
   for (const [key, definition] of Object.entries(viewDefinitions)) {
-    definition.setKey(key);
+    definition.key = key;
     output[key] = createView(definition, source);
   }
   return output;
@@ -28,7 +36,7 @@ export function createStoreView(viewDefinitions, source) {
 export function createStoreAction(actionDefinitions, model, view) {
   const output = {};
   for (const [key, definition] of Object.entries(actionDefinitions)) {
-    definition.setKey(key);
+    definition.key = key;
     output[key] = createAction(definition, model, view);
   }
   return output;

package/dist/runtime/index.d.ts

@@ -2,11 +2,11 @@ export { createStore } from "./core/store.js";
 export type { Store, StoreConfig } from "./core/types/store.js";
 export { shape } from "./core/layers/shape.js";
 export type { ShapeInfer } from "./core/types/shape.js";
-export { ModelKind, ModelOneMode, ModelManyMode } from "./core/types/model.js";
+export { ModelType, ModelManyKind, ModelOneMode, ModelManyMode } from "./core/types/model.js";
 export type { ModelOneCommitOptions, ModelManyCommitOptions } from "./core/types/model.js";
 export { ViewClone } from "./core/types/view.js";
 export type { ViewDefinitionOptions } from "./core/types/view.js";
-export { ActionStatus, ActionConcurrent, ActionApiMethod } from "./core/types/action.js";
+export { ActionStatus, ActionConcurrent, ActionType, ActionApiMethod } from "./core/types/action.js";
 export type { ActionCall, ActionApiCall, ActionHandlerCall, ActionCallOptions, ActionCallBaseOptions, ActionApiCallOptions, ActionHandlerCallOptions, ActionCallTransformerOptions, ActionCallBindOptions, ActionCallCommitOptions, ActionHandlerOptions, ActionResolvedApi, } from "./core/types/action.js";
 export { ActionApiError, ActionHandlerError, ActionCommitError, ActionConcurrentError } from "./core/utils/error.js";
 export { useIsolatedActionStatus, useIsolatedActionError, useStoreAction } from "./composables/action.js";

package/dist/runtime/index.js

@@ -1,8 +1,8 @@
 export { createStore } from "./core/store.js";
 export { shape } from "./core/layers/shape.js";
-export { ModelKind, ModelOneMode, ModelManyMode } from "./core/types/model.js";
+export { ModelType, ModelManyKind, ModelOneMode, ModelManyMode } from "./core/types/model.js";
 export { ViewClone } from "./core/types/view.js";
-export { ActionStatus, ActionConcurrent, ActionApiMethod } from "./core/types/action.js";
+export { ActionStatus, ActionConcurrent, ActionType, ActionApiMethod } from "./core/types/action.js";
 export { ActionApiError, ActionHandlerError, ActionCommitError, ActionConcurrentError } from "./core/utils/error.js";
 export { useIsolatedActionStatus, useIsolatedActionError, useStoreAction } from "./composables/action.js";
 export { useStoreModel } from "./composables/model.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diphyx/harlemify",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "API state management for Nuxt powered by Harlem",
   "keywords": [
     "nuxt",