@diphyx/harlemify 5.4.0 → 5.4.1

package/README.md

@@ -2,66 +2,40 @@
 
 > Factory-driven state management for Nuxt powered by [Harlem](https://harlemjs.com/)
 
-![Version](https://img.shields.io/badge/version-5.3.0-42b883)
-![License](https://img.shields.io/badge/license-MIT-blue)
-
 Define your data **shape** once with Zod — get typed **models**, computed **views**, and async **actions** with a single `createStore` call.
 
-Built on top of [Harlem](https://harlemjs.com/), a powerful and extensible state management library for Vue 3.
-
----
+- **Schema-first** — Define your data shape once, get TypeScript types and validation automatically
+- **Reactive state** — Single items and collections with built-in mutations
+- **Computed views** — Derived read-only state that updates when models change
+- **API integration** — Declarative HTTP actions that fetch and commit data in one step
+- **Status tracking** — Every action exposes loading, error, and status reactively
+- **Concurrency control** — Block, skip, cancel, or allow parallel calls per action
+- **Vue composables** — Reactive helpers for actions, models, and views in components
+- **SSR ready** — Server-side rendering with automatic state hydration
 
-## The Problem
+## Install
 
-Every Nuxt app has the same boilerplate for every API resource:
+```bash
+npm install @diphyx/harlemify
+```
 
 ```typescript
-// Without Harlemify — this gets written for EVERY resource
-
-// 1. Define types manually
-interface User {
-    id: number;
-    name: string;
-    email: string;
-}
-
-// 2. Define state
-const users = ref<User[]>([]);
-const currentUser = ref<User | null>(null);
-const loading = ref(false);
-const error = ref<Error | null>(null);
-
-// 3. Write fetch logic
-async function fetchUsers() {
-    loading.value = true;
-    error.value = null;
-    try {
-        users.value = await $fetch("/api/users");
-    } catch (e) {
-        error.value = e as Error;
-    } finally {
-        loading.value = false;
-    }
-}
-
-// 4. Repeat for create, update, delete...
-// 5. Repeat for every resource in your app...
+// nuxt.config.ts
+export default defineNuxtConfig({
+    modules: ["@diphyx/harlemify"],
+});
 ```
 
-## The Solution
-
-With Harlemify, define a data shape once and get everything else for free:
+## Usage
 
 ```typescript
-const userShape = shape((factory) => {
-    return {
-        id: factory.number().meta({
-            identifier: true,
-        }),
-        name: factory.string(),
-        email: factory.email(),
-    };
-});
+const userShape = shape((factory) => ({
+    id: factory.number().meta({
+        identifier: true,
+    }),
+    name: factory.string(),
+    email: factory.email(),
+}));
 
 export const userStore = createStore({
     name: "users",
@@ -83,49 +57,27 @@ export const userStore = createStore({
                 {
                     url: "/users",
                 },
-                { model: "list", mode: ModelManyMode.SET },
-            ),
-            get: api.get(
-                {
-                    url(view) {
-                        return `/users/${view.user.value?.id}`;
-                    },
-                },
-                { model: "current", mode: ModelOneMode.SET },
-            ),
-            create: api.post(
-                {
-                    url: "/users",
-                },
-                { model: "list", mode: ModelManyMode.ADD },
-            ),
-            delete: api.delete(
                 {
-                    url(view) {
-                        return `/users/${view.user.value?.id}`;
-                    },
+                    model: "list",
+                    mode: ModelManyMode.SET,
                 },
-                { model: "list", mode: ModelManyMode.REMOVE },
             ),
         };
     },
 });
 ```
 
-Use it in any component with built-in composables:
-
 ```vue
 <script setup>
-const { execute, loading, error } = useStoreAction(userStore, "list");
-const { data: users } = useStoreView(userStore, "users");
+const { execute, loading } = useStoreAction(userStore, "list");
+const { data } = useStoreView(userStore, "users");
 
 await execute();
 </script>
 
 <template>
-    <p v-if="error">{{ error.message }}</p>
-    <ul v-else-if="!loading">
-        <li v-for="user in users" :key="user.id">{{ user.name }}</li>
+    <ul v-if="!loading">
+        <li v-for="user in data" :key="user.id">{{ user.name }}</li>
     </ul>
 </template>
 ```
@@ -142,14 +94,8 @@ await execute();
 
 ## Documentation
 
-Full docs with guides, API reference, and examples:
-
 [https://diphyx.github.io/harlemify/](https://diphyx.github.io/harlemify/)
 
-## Contributing
-
-Contributions are welcome! Please open an issue first to discuss what you'd like to change.
-
 ## License
 
-[MIT](LICENSE)
+MIT

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^3.14.0 || ^4.0.0"
   },
-  "version": "5.4.0",
+  "version": "5.4.1",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

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

@@ -6,27 +6,10 @@ export interface UseStoreViewTrackOptions {
     debounce?: number;
     throttle?: number;
 }
-export interface UseStoreViewOptions {
-    proxy?: boolean;
-}
-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 & {
-    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): UseStoreViewProxy<T>;
+}, key: K): UseStoreView<T>;

package/dist/runtime/composables/view.js

@@ -1,17 +1,11 @@
 import { watch } from "vue";
-import { debounce, throttle, toReactiveProxy } from "../core/utils/base.js";
-function resolveData(source, proxy) {
-  if (proxy !== false) {
-    return toReactiveProxy(source);
-  }
-  return source;
-}
-export function useStoreView(store, key, options) {
+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 = store.view[key];
-  const data = resolveData(source, options?.proxy);
+  const data = source;
   function resolveCallback(callback, callbackOptions) {
     if (callbackOptions?.debounce) {
       return debounce(callback, callbackOptions.debounce);

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

@@ -17,5 +17,5 @@ export type { UseStoreActionOptions, UseStoreAction } from "./composables/action
 export { useStoreModel } from "./composables/model.js";
 export type { UseStoreModelOptions, UseStoreModel } from "./composables/model.js";
 export { useStoreView } from "./composables/view.js";
-export type { UseStoreViewOptions, UseStoreViewProxy, UseStoreViewComputed, UseStoreViewData, UseStoreViewTrackOptions, } from "./composables/view.js";
+export type { UseStoreView, UseStoreViewTrackOptions } from "./composables/view.js";
 export type { RuntimeConfig } from "./config.js";

package/package.json

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