@diphyx/harlemify 5.3.0 → 5.4.1

package/README.md

@@ -77,11 +77,21 @@ await execute();
 
 <template>
     <ul v-if="!loading">
-        <li v-for="user in data.value" :key="user.id">{{ user.name }}</li>
+        <li v-for="user in data" :key="user.id">{{ user.name }}</li>
     </ul>
 </template>
 ```
 
+## Compatibility
+
+| Dependency | Version               |
+| ---------- | --------------------- |
+| Nuxt       | `^3.14.0` or `^4.0.0` |
+| Vue        | `^3.5.0`              |
+| Zod        | `^4.0.0`              |
+
+> **Note:** Early Nuxt 4 versions (e.g., 4.1.x) may have issues resolving the `#build` alias for module templates. If you encounter build errors related to `#build/harlemify.config`, upgrade to the latest Nuxt 4 release.
+
 ## Documentation
 
 [https://diphyx.github.io/harlemify/](https://diphyx.github.io/harlemify/)

package/dist/module.json

@@ -2,9 +2,9 @@
   "name": "harlemify",
   "configKey": "harlemify",
   "compatibility": {
-    "nuxt": ">=3.0.0 || >=4.0.0"
+    "nuxt": "^3.14.0 || ^4.0.0"
   },
-  "version": "5.3.0",
+  "version": "5.4.1",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,17 +1,18 @@
-import { defineNuxtModule, createResolver, addTemplate, addPlugin, addImportsDir, addImports } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addTemplate, addPlugin, addImportsDir, addImports } from '@nuxt/kit';
 
+const logger = useLogger("harlemify");
 const module = defineNuxtModule({
   meta: {
     name: "harlemify",
     configKey: "harlemify",
     compatibility: {
-      nuxt: ">=3.0.0 || >=4.0.0"
+      nuxt: "^3.14.0 || ^4.0.0"
     }
   },
   defaults: {},
   setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    addTemplate({
+    const template = addTemplate({
       write: true,
       filename: "harlemify.config.mjs",
       getContents() {
@@ -27,6 +28,7 @@ const module = defineNuxtModule({
       }
     ]);
     nuxt.options.build.transpile.push(/@harlem\//);
+    logger.success(`Module registered, config template: ${template.dst}`);
   }
 });
 

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

@@ -0,0 +1,9 @@
+import type { Ref } from "vue";
+import type { ComposeCallback, ComposeDefinitions, StoreCompose } from "../core/types/compose.js";
+export type UseStoreCompose<A extends any[] = any[]> = {
+    execute: (...args: A) => Promise<void>;
+    active: Readonly<Ref<boolean>>;
+};
+export declare function useStoreCompose<CD extends ComposeDefinitions, K extends keyof StoreCompose<CD> & string, A extends any[] = CD[K] extends ComposeCallback<infer P> ? P : any[]>(store: {
+    compose: StoreCompose<CD>;
+}, key: K): UseStoreCompose<A>;

package/dist/runtime/composables/compose.js

@@ -0,0 +1,10 @@
+export function useStoreCompose(store, key) {
+  const compose = store.compose[key];
+  if (!compose) {
+    throw new Error(`Compose "${key}" not found in store`);
+  }
+  return {
+    execute: (...args) => compose(...args),
+    active: compose.active
+  };
+}

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

@@ -6,28 +6,10 @@ export interface UseStoreViewTrackOptions {
     debounce?: number;
     throttle?: number;
 }
-export interface UseStoreViewOptions<T> {
-    proxy?: boolean;
-    default?: T;
-}
-export type UseStoreViewData<T> = {
-    value: T;
-} & (T extends Record<string, unknown> ? {
-    [K in keyof T]: T[K];
-} : Record<string, unknown>);
-export type UseStoreViewProxy<T> = {
-    data: UseStoreViewData<T>;
-    track: (handler: (value: T) => void, options?: UseStoreViewTrackOptions) => WatchStopHandle;
-};
-export type UseStoreViewComputed<T> = {
+export type UseStoreView<T> = {
     data: ComputedRef<T>;
     track: (handler: (value: T) => void, options?: UseStoreViewTrackOptions) => WatchStopHandle;
 };
 export declare function useStoreView<V extends Record<string, ViewCall>, K extends keyof V & string, T = V[K] extends ComputedRef<infer R> ? R : unknown>(store: {
     view: V;
-}, key: K, options: UseStoreViewOptions<T> & {
-    proxy: false;
-}): UseStoreViewComputed<T>;
-export declare function useStoreView<V extends Record<string, ViewCall>, K extends keyof V & string, T = V[K] extends ComputedRef<infer R> ? R : unknown>(store: {
-    view: V;
-}, key: K, options?: UseStoreViewOptions<T>): UseStoreViewProxy<T>;
+}, key: K): UseStoreView<T>;

package/dist/runtime/composables/view.js

@@ -1,29 +1,11 @@
-import { computed, watch } from "vue";
-import { debounce, throttle, toReactiveProxy } from "../core/utils/base.js";
-function resolveDefault(view, defaultValue) {
-  if (defaultValue === void 0) {
-    return view;
-  }
-  return computed(() => {
-    const value = view.value;
-    if (value == null) {
-      return defaultValue;
-    }
-    return value;
-  });
-}
-function resolveData(source, proxy) {
-  if (proxy !== false) {
-    return toReactiveProxy(source);
-  }
-  return source;
-}
-export function useStoreView(store, key, options) {
+import { watch } from "vue";
+import { debounce, throttle } from "../core/utils/base.js";
+export function useStoreView(store, key) {
   if (!store.view[key]) {
     throw new Error(`View "${key}" not found in store`);
   }
-  const source = resolveDefault(store.view[key], options?.default);
-  const data = resolveData(source, options?.proxy);
+  const source = store.view[key];
+  const data = source;
   function resolveCallback(callback, callbackOptions) {
     if (callbackOptions?.debounce) {
       return debounce(callback, callbackOptions.debounce);

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

@@ -1,26 +1,55 @@
 import { wrapBaseDefinition } from "../utils/base.js";
+import { resolveShapeIdentifier } from "../utils/shape.js";
 import {
-  ModelType
+  ModelType,
+  ModelManyKind
 } from "../types/model.js";
 export function createModelFactory(config, logger) {
   function one(shape, options) {
+    function defaultResolver() {
+      if (options?.default) {
+        return options.default();
+      }
+      if ("defaults" in shape && typeof shape.defaults === "function") {
+        return shape.defaults();
+      }
+      return {};
+    }
     return wrapBaseDefinition({
       shape,
       type: ModelType.ONE,
+      default: defaultResolver,
       options: {
-        identifier: config?.identifier,
-        ...options
+        pre: options?.pre,
+        post: options?.post
       },
       logger
     });
   }
   function many(shape, options) {
+    const kind = options?.kind ?? ModelManyKind.LIST;
+    let identifier;
+    if (kind === ModelManyKind.LIST) {
+      identifier = resolveShapeIdentifier(shape, options?.identifier, config?.identifier);
+    }
+    function defaultResolver() {
+      if (options?.default) {
+        return options.default();
+      }
+      if (kind === ModelManyKind.LIST) {
+        return [];
+      }
+      return {};
+    }
     return wrapBaseDefinition({
       shape,
       type: ModelType.MANY,
+      kind,
+      identifier,
+      default: defaultResolver,
       options: {
-        identifier: config?.identifier,
-        ...options
+        pre: options?.pre,
+        post: options?.post
       },
       logger
     });

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

@@ -1,5 +1,6 @@
 import type { ModelDefinitions } from "./types/model.js";
 import type { ViewDefinitions } from "./types/view.js";
 import type { ActionDefinitions } from "./types/action.js";
+import type { ComposeDefinitions } from "./types/compose.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>;
+export declare function createStore<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>, CD extends ComposeDefinitions = ComposeDefinitions>(config: StoreConfig<MD, VD, AD, CD>): Store<MD, VD, AD, CD>;

package/dist/runtime/core/store.js

@@ -5,29 +5,46 @@ import { createModelFactory } from "./layers/model.js";
 import { createViewFactory } from "./layers/view.js";
 import { createActionFactory } from "./layers/action.js";
 import { createStoreState, createStoreModel, createStoreView, createStoreAction } from "./utils/store.js";
+import { createStoreCompose } from "./utils/compose.js";
 export function createStore(config) {
-  const logger = createConsola({
-    level: runtimeConfig.logger,
-    defaults: {
-      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);
-  const modelDefinitions = config.model(modelFactory);
-  const viewDefinitions = config.view(viewFactory);
-  const actionDefinitions = config.action(actionFactory);
-  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,
-    view,
-    action
-  };
+  function init() {
+    const logger = createConsola({
+      level: runtimeConfig.logger,
+      defaults: {
+        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);
+    const modelDefinitions = config.model(modelFactory);
+    const viewDefinitions = config.view(viewFactory);
+    const actionDefinitions = config.action(actionFactory);
+    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);
+    const compose = createStoreCompose(config.compose, { model, view, action }, logger);
+    logger.info("Store created");
+    return {
+      model,
+      view,
+      action,
+      compose
+    };
+  }
+  if (config.lazy) {
+    let instance;
+    return new Proxy({}, {
+      get(_, prop) {
+        if (!instance) {
+          instance = init();
+        }
+        return instance[prop];
+      }
+    });
+  }
+  return init();
 }

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

@@ -64,7 +64,7 @@ export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDe
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
     payload: P;
-}) => Promise<R>;
+}) => Promise<R> | R;
 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>;

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

@@ -0,0 +1,18 @@
+import type { Ref } from "vue";
+import type { ModelDefinitions, StoreModel } from "./model.js";
+import type { ViewDefinitions, StoreView } from "./view.js";
+import type { ActionDefinitions, StoreAction } from "./action.js";
+export type ComposeCallback<A extends any[] = any[]> = (...args: A) => Promise<void> | void;
+export type ComposeDefinitions = Record<string, ComposeCallback<any[]>>;
+export interface ComposeContext<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
+    model: StoreModel<MD>;
+    view: StoreView<MD, VD>;
+    action: StoreAction<MD, VD, AD>;
+}
+export type ComposeCall<A extends any[] = any[]> = {
+    (...args: A): Promise<void>;
+    active: Readonly<Ref<boolean>>;
+};
+export type StoreCompose<CD extends ComposeDefinitions> = {
+    [K in keyof CD]: CD[K] extends ComposeCallback<infer A> ? ComposeCall<A> : never;
+};

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

@@ -23,33 +23,35 @@ export declare enum ModelManyMode {
     REMOVE = "remove",
     ADD = "add"
 }
+export declare enum ModelSilent {
+    PRE = "pre",
+    POST = "post"
+}
 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 ModelDefinitionOptions {
+    pre?: () => void;
+    post?: () => void;
 }
-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>;
     type: ModelType.ONE;
-    options?: ModelOneDefinitionOptions<S>;
+    default: () => S;
+    options?: ModelDefinitionOptions;
 }
 export interface ModelManyDefinition<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> extends BaseDefinition {
     shape: ShapeType<S>;
     type: ModelType.MANY;
-    options?: ModelManyDefinitionOptions<S, I, T>;
+    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, 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, any, infer T> ? [T] extends [ModelManyKind.LIST] ? S[] : Record<string, 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;
 };
@@ -57,36 +59,47 @@ 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, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST>(shape: ShapeType<S>, options?: ModelManyDefinitionOptions<S, I, T>): ModelManyDefinition<S, I, T>;
+    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: (value: S[]) => void;
-    reset: () => void;
-    patch: (value: Partial<S> | Partial<S>[], options?: ModelManyCommitOptions) => void;
-    remove: (value: Pick<S, I> | Pick<S, I>[] | AtLeastOne<S> | AtLeastOne<S>[]) => void;
-    add: (value: S | S[], options?: ModelManyCommitOptions) => void;
+    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 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;
+    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> & {

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

@@ -22,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/base.d.ts

@@ -6,12 +6,5 @@ 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;
-type ReferenceProxy<T> = {
-    value: T;
-} & Record<string | symbol, unknown>;
-export declare function toReactiveProxy<T>(reference: {
-    value: T;
-}): ReferenceProxy<T>;
 export declare function debounce<T extends (...args: any[]) => any>(callback: T, delay: number): T;
 export declare function throttle<T extends (...args: any[]) => any>(callback: T, delay: number): T;
-export {};

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

@@ -43,51 +43,6 @@ export function isEmptyRecord(record) {
   }
   return false;
 }
-export function toReactiveProxy(reference) {
-  function get(_target, prop) {
-    if (prop === "value") {
-      return reference.value;
-    }
-    if (!isObject(reference.value)) {
-      return void 0;
-    }
-    return reference.value[prop];
-  }
-  function has(_target, prop) {
-    if (prop === "value") {
-      return true;
-    }
-    if (!isObject(reference.value)) {
-      return false;
-    }
-    return prop in reference.value;
-  }
-  function ownKeys() {
-    if (!isObject(reference.value)) {
-      return [];
-    }
-    return Reflect.ownKeys(reference.value);
-  }
-  function getOwnPropertyDescriptor(_target, prop) {
-    if (!isObject(reference.value) || !(prop in reference.value)) {
-      return void 0;
-    }
-    return {
-      configurable: true,
-      enumerable: true,
-      value: reference.value[prop]
-    };
-  }
-  return new Proxy(
-    {},
-    {
-      get,
-      has,
-      ownKeys,
-      getOwnPropertyDescriptor
-    }
-  );
-}
 export function debounce(callback, delay) {
   let timer = null;
   return (...args) => {

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;
+}