@diphyx/harlemify 5.2.0 → 5.4.0

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,35 @@ export declare enum ModelManyMode {
     REMOVE = "remove",
     ADD = "add"
 }
-export interface ModelOneDefinitionOptions<S extends Shape> {
-    identifier?: keyof S;
-    default?: S;
+export declare enum ModelSilent {
+    PRE = "pre",
+    POST = "post"
 }
-export interface ModelManyDefinitionOptions<S extends Shape> {
-    identifier?: keyof S;
-    default?: S[];
+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 ModelDefinitionOptions {
+    pre?: () => void;
+    post?: () => void;
 }
 export interface ModelOneDefinition<S extends Shape> extends BaseDefinition {
     shape: ShapeType<S>;
-    kind: ModelKind.OBJECT;
-    options?: ModelOneDefinitionOptions<S>;
+    type: ModelType.ONE;
+    default: () => S;
+    options?: ModelDefinitionOptions;
 }
-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;
+    kind: T;
+    identifier: [T] extends [ModelManyKind.LIST] ? I : never;
+    default: () => [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>;
+    options?: ModelDefinitionOptions;
 }
-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 : 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;
 };
@@ -47,39 +59,58 @@ export type ModelDefinitionsInfer<MD extends ModelDefinitions> = {
     [K in keyof MD]: ModelDefinitionInfer<MD, K>;
 };
 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>;
+    one<S extends Shape>(shape: ShapeType<S>, options?: ModelDefinitionOptions & {
+        default?: () => S;
+    }): ModelOneDefinition<S>;
+    many<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST>(shape: ShapeType<S>, options?: ModelDefinitionOptions & {
+        kind?: T;
+        identifier?: [T] extends [ModelManyKind.LIST] ? I : never;
+        default?: () => [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>;
+    }): ModelManyDefinition<S, I, T>;
 }
 export interface ModelOneCommitOptions {
     deep?: boolean;
+    silent?: true | ModelSilent;
 }
 export interface ModelManyCommitOptions {
     by?: string;
     prepend?: boolean;
     unique?: boolean;
     deep?: boolean;
+    silent?: true | ModelSilent;
 }
 export interface ModelOneCommit<S extends Shape> {
-    set: (value: S) => void;
-    reset: () => void;
-    patch: (value: Partial<S>, options?: ModelOneCommitOptions) => void;
+    set: (payload: S, options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    reset: (options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    patch: (payload: Partial<S>, options?: Pick<ModelOneCommitOptions, "deep" | "silent">) => void;
+}
+export interface ModelManyListCommit<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>> {
+    set: (payload: S[], options?: Pick<ModelManyCommitOptions, "silent">) => void;
+    reset: (options?: Pick<ModelManyCommitOptions, "silent">) => void;
+    patch: (payload: Partial<S> | Partial<S>[], options?: Pick<ModelManyCommitOptions, "by" | "deep" | "silent">) => void;
+    remove: (payload: Pick<S, I> | Pick<S, I>[] | AtLeastOne<S> | AtLeastOne<S>[], options?: Pick<ModelManyCommitOptions, "silent">) => void;
+    add: (payload: S | S[], options?: Pick<ModelManyCommitOptions, "by" | "prepend" | "unique" | "silent">) => void;
 }
-export interface ModelManyCommit<S extends Shape> {
-    set: (value: S[]) => void;
-    reset: () => 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 interface ModelManyRecordCommit<S extends Shape> {
+    set: (payload: Record<string, S[]>, options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    reset: (options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    patch: (payload: Record<string, S[]>, options?: Pick<ModelOneCommitOptions, "deep" | "silent">) => void;
+    remove: (payload: string, options?: Pick<ModelOneCommitOptions, "silent">) => void;
+    add: (payload: {
+        key: string;
+        value: S[];
+    }, options?: Pick<ModelOneCommitOptions, "silent">) => 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";
@@ -17,3 +22,8 @@ export var ModelManyMode = /* @__PURE__ */ ((ModelManyMode2) => {
   ModelManyMode2["ADD"] = "add";
   return ModelManyMode2;
 })(ModelManyMode || {});
+export var ModelSilent = /* @__PURE__ */ ((ModelSilent2) => {
+  ModelSilent2["PRE"] = "pre";
+  ModelSilent2["POST"] = "post";
+  return ModelSilent2;
+})(ModelSilent || {});

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

@@ -7,12 +7,6 @@ export type ShapeInfer<T extends z.ZodType<any>> = z.infer<T>;
 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: (keyof T["shape"] & string)[];
-    aliases: Record<string, string>;
-}
 export interface ShapeFieldDefinition {
     meta?: {
         identifier?: boolean;

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

@@ -1,14 +1,18 @@
 import type { ModelDefinitions, ModelFactory, StoreModel } from "./model.js";
 import type { ViewDefinitions, ViewFactory, StoreView } from "./view.js";
 import type { ActionDefinitions, ActionFactory, StoreAction } from "./action.js";
-export interface StoreConfig<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
+import type { ComposeDefinitions, ComposeContext, StoreCompose } from "./compose.js";
+export interface StoreConfig<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>, CD extends ComposeDefinitions = ComposeDefinitions> {
     name: string;
     model: (factory: ModelFactory) => MD;
     view: (factory: ViewFactory<MD>) => VD;
     action: (factory: ActionFactory<MD, VD>) => AD;
+    compose?: (context: ComposeContext<MD, VD, AD>) => CD;
+    lazy?: boolean;
 }
-export interface Store<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
+export interface Store<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>, CD extends ComposeDefinitions = ComposeDefinitions> {
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
     action: StoreAction<MD, VD, AD>;
+    compose: StoreCompose<CD>;
 }

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/compose.d.ts

@@ -0,0 +1,3 @@
+import type { ConsolaInstance } from "consola";
+import type { ComposeDefinitions, StoreCompose } from "../types/compose.js";
+export declare function createStoreCompose<CD extends ComposeDefinitions>(composeConfig: ((...args: any[]) => CD) | undefined, context: Record<string, unknown>, logger?: ConsolaInstance): StoreCompose<CD>;

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

@@ -0,0 +1,37 @@
+import { ref, readonly } from "vue";
+function createComposeAction(key, callback, logger) {
+  logger?.debug("Registering compose action", {
+    action: key
+  });
+  const active = ref(false);
+  async function execute(...args) {
+    active.value = true;
+    try {
+      logger?.debug("Compose action executing", {
+        action: key
+      });
+      await callback(...args);
+      logger?.debug("Compose action success", {
+        action: key
+      });
+    } finally {
+      active.value = false;
+    }
+  }
+  return Object.assign(execute, {
+    get active() {
+      return readonly(active);
+    }
+  });
+}
+export function createStoreCompose(composeConfig, context, logger) {
+  const output = {};
+  if (!composeConfig) {
+    return output;
+  }
+  const composeDefinitions = composeConfig(context);
+  for (const [key, callback] of Object.entries(composeDefinitions)) {
+    output[key] = createComposeAction(key, callback, logger);
+  }
+  return output;
+}