@diphyx/harlemify 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Amir Reza Dalir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+# Harlemify
+
+API state management for Nuxt powered by [Harlem](https://harlemjs.com/)
+
+![Harlemify](https://raw.githubusercontent.com/diphyx/harlemify/main/docs/_media/icon.svg)
+
+## Features
+
+- Zod schema validation with field metadata
+- Automatic API client with runtime config
+- CRUD operations with endpoint status tracking
+- SSR support via Harlem SSR plugin
+
+## Installation
+
+```bash
+npm install @diphyx/harlemify
+```
+
+## Quick Start
+
+```typescript
+// nuxt.config.ts
+export default defineNuxtConfig({
+    modules: ["@diphyx/harlemify"],
+    harlemify: {
+        api: {
+            url: "https://api.example.com",
+        },
+    },
+});
+```
+
+```typescript
+// stores/user.ts
+import { z, createStore, Endpoint, ApiAction } from "@diphyx/harlemify";
+
+const UserSchema = z.object({
+    id: z.number().meta({
+        indicator: true,
+    }),
+    name: z.string().meta({
+        actions: [ApiAction.POST, ApiAction.PUT],
+    }),
+});
+
+export const userStore = createStore("user", UserSchema, {
+    [Endpoint.GET_UNITS]: {
+        action: ApiAction.GET,
+        url: "/users",
+    },
+    [Endpoint.POST_UNIT]: {
+        action: ApiAction.POST,
+        url: "/users",
+    },
+});
+```
+
+## Documentation
+
+Full documentation available at [https://diphyx.github.io/harlemify/](https://diphyx.github.io/harlemify/)
+
+## License
+
+MIT

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.mts

@@ -0,0 +1,19 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { MaybeRefOrGetter } from 'vue';
+
+type ApiRequestHeader = MaybeRefOrGetter<Record<string, unknown>>;
+type ApiRequestQuery = MaybeRefOrGetter<Record<string, unknown>>;
+interface ApiOptions {
+    url?: string;
+    headers?: ApiRequestHeader;
+    query?: ApiRequestQuery;
+    timeout?: number;
+}
+
+interface ModuleOptions {
+    api?: Pick<ApiOptions, "url" | "timeout">;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.d.ts

@@ -0,0 +1,19 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { MaybeRefOrGetter } from 'vue';
+
+type ApiRequestHeader = MaybeRefOrGetter<Record<string, unknown>>;
+type ApiRequestQuery = MaybeRefOrGetter<Record<string, unknown>>;
+interface ApiOptions {
+    url?: string;
+    headers?: ApiRequestHeader;
+    query?: ApiRequestQuery;
+    timeout?: number;
+}
+
+interface ModuleOptions {
+    api?: Pick<ApiOptions, "url" | "timeout">;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "harlemify",
+  "configKey": "harlemify",
+  "compatibility": {
+    "nuxt": ">=3.0.0 || >=4.0.0"
+  },
+  "version": "0.0.1",
+  "builder": {
+    "@nuxt/module-builder": "0.8.4",
+    "unbuild": "unknown"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,31 @@
+import { defineNuxtModule, createResolver, addPlugin, addImportsDir, updateRuntimeConfig } from '@nuxt/kit';
+
+const module = defineNuxtModule({
+  meta: {
+    name: "harlemify",
+    configKey: "harlemify",
+    compatibility: {
+      nuxt: ">=3.0.0 || >=4.0.0"
+    }
+  },
+  defaults: {
+    api: {}
+  },
+  setup(options, _) {
+    const { resolve } = createResolver(import.meta.url);
+    addPlugin(resolve("./runtime", "plugin"));
+    addImportsDir(resolve("./runtime", "core"));
+    updateRuntimeConfig({
+      public: {
+        harlemify: options
+      },
+      options: {
+        build: {
+          transpile: [/@harlem\//]
+        }
+      }
+    });
+  }
+});
+
+export { module as default };

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

@@ -0,0 +1,63 @@
+import { type MaybeRefOrGetter } from "vue";
+export declare enum ApiAction {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    PATCH = "patch",
+    DELETE = "delete"
+}
+export declare enum ApiResponseType {
+    JSON = "json",
+    TEXT = "text",
+    BLOB = "blob",
+    ARRAY_BUFFER = "arrayBuffer"
+}
+export declare enum ApiErrorSource {
+    REQUEST = "request",
+    RESPONSE = "response"
+}
+export type ApiRequestHeader = MaybeRefOrGetter<Record<string, unknown>>;
+export type ApiRequestQuery = MaybeRefOrGetter<Record<string, unknown>>;
+export type ApiRequestBody = MaybeRefOrGetter<string | number | ArrayBuffer | FormData | Blob | Record<string, any>>;
+export interface ApiRequestOptions<A extends ApiAction = ApiAction, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> {
+    action?: A;
+    headers?: H;
+    query?: Q;
+    body?: B;
+    responseType?: ApiResponseType;
+    retry?: number | false;
+    retryDelay?: number;
+    retryStatusCodes?: number[];
+}
+export interface ApiOptions {
+    url?: string;
+    headers?: ApiRequestHeader;
+    query?: ApiRequestQuery;
+    timeout?: number;
+}
+export type ApiActionOptions<A extends ApiAction, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> = Omit<ApiRequestOptions<A, H, Q, B>, "action">;
+export interface ApiErrorOptions {
+    source: ApiErrorSource;
+    method: string;
+    url: string;
+    message?: string;
+}
+export declare class ApiError extends Error {
+    source: ApiErrorSource;
+    method: string;
+    url: string;
+    constructor(options: ApiErrorOptions);
+}
+export declare class ApiRequestError extends ApiError {
+    constructor(options: Omit<ApiErrorOptions, "source">);
+}
+export declare class ApiResponseError extends ApiError {
+    constructor(options: Omit<ApiErrorOptions, "source">);
+}
+export declare function createApi(options?: ApiOptions): {
+    get: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.GET, H, Q, never>) => Promise<T>;
+    post: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.POST, H, Q, B>) => Promise<T>;
+    put: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PUT, H, Q, B>) => Promise<T>;
+    patch: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PATCH, H, Q, B>) => Promise<T>;
+    del: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.DELETE, H, Q, never>) => Promise<T>;
+};

package/dist/runtime/core/api.js

@@ -0,0 +1,122 @@
+import { toValue } from "vue";
+export var ApiAction = /* @__PURE__ */ ((ApiAction2) => {
+  ApiAction2["GET"] = "get";
+  ApiAction2["POST"] = "post";
+  ApiAction2["PUT"] = "put";
+  ApiAction2["PATCH"] = "patch";
+  ApiAction2["DELETE"] = "delete";
+  return ApiAction2;
+})(ApiAction || {});
+export var ApiResponseType = /* @__PURE__ */ ((ApiResponseType2) => {
+  ApiResponseType2["JSON"] = "json";
+  ApiResponseType2["TEXT"] = "text";
+  ApiResponseType2["BLOB"] = "blob";
+  ApiResponseType2["ARRAY_BUFFER"] = "arrayBuffer";
+  return ApiResponseType2;
+})(ApiResponseType || {});
+export var ApiErrorSource = /* @__PURE__ */ ((ApiErrorSource2) => {
+  ApiErrorSource2["REQUEST"] = "request";
+  ApiErrorSource2["RESPONSE"] = "response";
+  return ApiErrorSource2;
+})(ApiErrorSource || {});
+export class ApiError extends Error {
+  source;
+  method;
+  url;
+  constructor(options) {
+    super(options.message || "Unknown error");
+    this.name = "ApiError";
+    this.source = options.source;
+    this.method = options.method;
+    this.url = options.url;
+  }
+}
+export class ApiRequestError extends ApiError {
+  constructor(options) {
+    super({
+      ...options,
+      source: "request" /* REQUEST */
+    });
+  }
+}
+export class ApiResponseError extends ApiError {
+  constructor(options) {
+    super({
+      ...options,
+      source: "response" /* RESPONSE */
+    });
+  }
+}
+export function createApi(options) {
+  async function request(url, requestOptions) {
+    return $fetch(url, {
+      baseURL: options?.url,
+      method: requestOptions?.action ?? "get" /* GET */,
+      headers: {
+        ...toValue(options?.headers),
+        ...toValue(requestOptions?.headers)
+      },
+      query: {
+        ...toValue(requestOptions?.query),
+        ...toValue(options?.query)
+      },
+      body: toValue(requestOptions?.body),
+      timeout: requestOptions?.timeout ?? options?.timeout,
+      responseType: requestOptions?.responseType,
+      retry: requestOptions?.retry,
+      retryDelay: requestOptions?.retryDelay,
+      retryStatusCodes: requestOptions?.retryStatusCodes,
+      onRequestError({ request: request2, options: options2, error }) {
+        throw new ApiRequestError({
+          method: options2.method,
+          url: request2.toString(),
+          message: error?.message
+        });
+      },
+      onResponseError({ request: request2, options: options2, error }) {
+        throw new ApiResponseError({
+          method: options2.method,
+          url: request2.toString(),
+          message: error?.message
+        });
+      }
+    });
+  }
+  async function get(url, options2) {
+    return request(url, {
+      ...options2,
+      action: "get" /* GET */
+    });
+  }
+  async function post(url, options2) {
+    return request(url, {
+      ...options2,
+      action: "post" /* POST */
+    });
+  }
+  async function put(url, options2) {
+    return request(url, {
+      ...options2,
+      action: "put" /* PUT */
+    });
+  }
+  async function patch(url, options2) {
+    return request(url, {
+      ...options2,
+      action: "patch" /* PATCH */
+    });
+  }
+  async function del(url, options2) {
+    return request(url, {
+      ...options2,
+      action: "delete" /* DELETE */
+    });
+  }
+  return {
+    get,
+    post,
+    put,
+    patch,
+    del
+  };
+}

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

@@ -0,0 +1,125 @@
+import { z } from "zod";
+import { type Extension, type BaseState } from "@harlem/core";
+import { Endpoint, type EndpointDefinition, type EndpointMemory } from "../utils/endpoint.js";
+import { ApiAction, type ApiActionOptions, type ApiOptions } from "./api.js";
+export declare function createStore<T extends z.ZodRawShape>(name: string, schema: z.ZodObject<T>, endpoints?: Partial<Record<Endpoint, EndpointDefinition>>, options?: {
+    api?: ApiOptions;
+    extensions?: Extension<BaseState>[];
+}): {
+    api: {
+        get: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.GET, H, Q, never>) => Promise<T_1>;
+        post: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery, B extends import("./api").ApiRequestBody = import("./api").ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.POST, H, Q, B>) => Promise<T_1>;
+        put: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery, B extends import("./api").ApiRequestBody = import("./api").ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PUT, H, Q, B>) => Promise<T_1>;
+        patch: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery, B extends import("./api").ApiRequestBody = import("./api").ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PATCH, H, Q, B>) => Promise<T_1>;
+        del: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.DELETE, H, Q, never>) => Promise<T_1>;
+    };
+    store: Omit<import("@harlem/core").Store<{
+        memory: {
+            unit: z.core.$InferObjectOutput<T, {}> | null;
+            units: z.core.$InferObjectOutput<T, {}>[];
+        };
+        endpoints: Record<Endpoint, EndpointMemory>;
+    }>, never>;
+    memorizedUnit: import("@vue/reactivity").ComputedRef<import("@vue/reactivity").DeepReadonly<z.core.$InferObjectOutput<T, {}>> | null>;
+    memorizedUnits: import("@vue/reactivity").ComputedRef<readonly import("@vue/reactivity").DeepReadonly<z.core.$InferObjectOutput<T, {}>>[]>;
+    hasMemorizedUnits: (...units: ({
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => Record<keyof z.core.$InferObjectOutput<T, {}>, boolean>;
+    endpointsStatus: {
+        getUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        getUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        getUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        getUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+        getUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        getUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        getUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        getUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+        postUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        postUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        postUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        postUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+        postUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        postUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        postUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        postUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+        putUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        putUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        putUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        putUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+        putUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        putUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        putUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        putUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+        patchUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        patchUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        patchUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        patchUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+        patchUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        patchUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        patchUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        patchUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+        deleteUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        deleteUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        deleteUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        deleteUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+        deleteUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
+        deleteUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
+        deleteUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
+        deleteUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+    };
+    setMemorizedUnit: import("@harlem/core").Mutation<z.core.$InferObjectOutput<T, {}> | null, void>;
+    setMemorizedUnits: (payload: z.core.$InferObjectOutput<T, {}>[]) => void;
+    editMemorizedUnit: import("@harlem/core").Mutation<{
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>, void>;
+    editMemorizedUnits: (payload: ({
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => void;
+    dropMemorizedUnit: import("@harlem/core").Mutation<{
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>, void>;
+    dropMemorizedUnits: (payload: ({
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => void;
+    patchEndpointMemory: (payload: {
+        key: Endpoint;
+        memory: EndpointMemory;
+    }) => void;
+    purgeEndpointMemory: (payload?: unknown) => void;
+    getUnit: (unit: {
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>, options?: Omit<ApiActionOptions<ApiAction.GET>, "body">) => Promise<z.core.$InferObjectOutput<T, {}>>;
+    getUnits: (options?: Omit<ApiActionOptions<ApiAction.GET>, "body">) => Promise<z.core.$InferObjectOutput<T, {}>[]>;
+    postUnit: (unit: z.core.$InferObjectOutput<T, {}>, options?: ApiActionOptions<ApiAction.POST> & {
+        validate?: boolean;
+    }) => Promise<z.core.$InferObjectOutput<T, {}>>;
+    postUnits: (units: z.core.$InferObjectOutput<T, {}>[], options?: ApiActionOptions<ApiAction.POST> & {
+        validate?: boolean;
+    }) => Promise<z.core.$InferObjectOutput<T, {}>[]>;
+    putUnit: (unit: z.core.$InferObjectOutput<T, {}>, options?: ApiActionOptions<ApiAction.PUT> & {
+        validate?: boolean;
+    }) => Promise<z.core.$InferObjectOutput<T, {}>>;
+    putUnits: (units: z.core.$InferObjectOutput<T, {}>[], options?: ApiActionOptions<ApiAction.PUT> & {
+        validate?: boolean;
+    }) => Promise<z.core.$InferObjectOutput<T, {}>[]>;
+    patchUnit: (unit: {
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>, options?: ApiActionOptions<ApiAction.PATCH> & {
+        validate?: boolean;
+    }) => Promise<{
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>>;
+    patchUnits: (units: ({
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>)[], options?: ApiActionOptions<ApiAction.PATCH> & {
+        validate?: boolean;
+    }) => Promise<({
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>)[]>;
+    deleteUnit: (unit: {
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>, options?: Omit<ApiActionOptions<ApiAction.DELETE>, "body">) => Promise<boolean>;
+    deleteUnits: (units: ({
+        [x: string]: keyof z.core.$InferObjectOutput<T, {}>;
+    } & Partial<z.core.$InferObjectOutput<T, {}>>)[], options?: Omit<ApiActionOptions<ApiAction.DELETE>, "body">) => Promise<boolean>;
+};

package/dist/runtime/core/store.js

@@ -0,0 +1,440 @@
+import { defu } from "defu";
+import {
+  createStore as createHarlemStore
+} from "@harlem/core";
+import { resolveSchema } from "../utils/schema.js";
+import {
+  makeEndpointStatusKey,
+  getEndpoint,
+  resolveEndpointUrl,
+  makeEndpointsStatus,
+  Endpoint,
+  EndpointStatus
+} from "../utils/endpoint.js";
+import {
+  createApi
+} from "./api.js";
+export function createStore(name, schema, endpoints, options) {
+  const config = useRuntimeConfig();
+  const api = createApi({
+    ...config.public.harlemify.api,
+    ...options?.api
+  });
+  const { indicator } = resolveSchema(schema);
+  const store = createHarlemStore(
+    name,
+    {
+      memory: {
+        unit: null,
+        units: []
+      },
+      endpoints: {}
+    },
+    {
+      extensions: options?.extensions ?? []
+    }
+  );
+  const memorizedUnit = store.getter("memorizedUnit", (state) => {
+    return state.memory.unit;
+  });
+  const memorizedUnits = store.getter("memorizedUnits", (state) => {
+    return state.memory.units;
+  });
+  function hasMemorizedUnits(...units) {
+    const output = {};
+    for (const unit of units) {
+      const exists = memorizedUnits.value.some((memorizedUnit2) => {
+        return memorizedUnit2[indicator] === unit[indicator];
+      });
+      output[unit[indicator]] = exists;
+    }
+    return output;
+  }
+  const setMemorizedUnit = store.mutation(
+    "setMemorizedUnit",
+    (state, unit = null) => {
+      state.memory.unit = unit;
+    }
+  );
+  const setMemorizedUnits = store.mutation(
+    "setMemorizedUnits",
+    (state, units = []) => {
+      state.memory.units = units;
+    }
+  );
+  const editMemorizedUnit = store.mutation(
+    "editMemorizedUnit",
+    (state, unit) => {
+      if (state.memory.unit?.[indicator] === unit[indicator]) {
+        state.memory.unit = defu(unit, state.memory.unit);
+      }
+    }
+  );
+  const editMemorizedUnits = store.mutation(
+    "editMemorizedUnits",
+    (state, units) => {
+      for (const unit of units) {
+        const index = state.memory.units.findIndex((memorizedUnit2) => {
+          return memorizedUnit2[indicator] === unit[indicator];
+        });
+        if (index !== -1) {
+          state.memory.units[index] = defu(
+            unit,
+            state.memory.units[index]
+          );
+        }
+      }
+    }
+  );
+  const dropMemorizedUnit = store.mutation(
+    "dropMemorizedUnit",
+    (state, unit) => {
+      if (state.memory.unit?.[indicator] === unit[indicator]) {
+        state.memory.unit = null;
+      }
+    }
+  );
+  const dropMemorizedUnits = store.mutation(
+    "dropMemorizedUnits",
+    (state, units) => {
+      state.memory.units = state.memory.units.filter((memorizedUnit2) => {
+        for (const unit of units) {
+          if (memorizedUnit2[indicator] === unit[indicator]) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+  );
+  const endpointsStatus = makeEndpointsStatus(store.getter);
+  const patchEndpointMemory = store.mutation(
+    "patchEndpointMemory",
+    (state, {
+      key,
+      memory
+    }) => {
+      state.endpoints[key] = memory;
+    }
+  );
+  const purgeEndpointMemory = store.mutation(
+    "purgeEndpointMemory",
+    (state) => {
+      state.endpoints = {};
+    }
+  );
+  function patchEndpointMemoryTo(key, memory) {
+    if (memory.status === EndpointStatus.PENDING) {
+      const statusKey = makeEndpointStatusKey(
+        key,
+        EndpointStatus.PENDING
+      );
+      if (endpointsStatus[statusKey].value) {
+        throw new Error(`Endpoint "${key}" is already pending`);
+      }
+    }
+    patchEndpointMemory({
+      key,
+      memory
+    });
+  }
+  async function getUnit(unit, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.GET_UNIT);
+    patchEndpointMemoryTo(Endpoint.GET_UNIT, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
+        [indicator]: unit[indicator]
+      });
+      const response = await api.get(resolvedUrl, options2);
+      setMemorizedUnit(response);
+      patchEndpointMemoryTo(Endpoint.GET_UNIT, {
+        status: EndpointStatus.SUCCESS
+      });
+      return response;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.GET_UNIT, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  async function getUnits(options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.GET_UNITS);
+    patchEndpointMemoryTo(Endpoint.GET_UNITS, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url);
+      const response = await api.get(resolvedUrl, options2);
+      setMemorizedUnits(response);
+      patchEndpointMemoryTo(Endpoint.GET_UNITS, {
+        status: EndpointStatus.SUCCESS
+      });
+      return response;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.GET_UNITS, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  async function postUnit(unit, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.POST_UNIT);
+    const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+    if (options2?.validate) {
+      schema.pick(resolvedSchema.keys).parse(unit);
+    }
+    patchEndpointMemoryTo(Endpoint.POST_UNIT, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
+        [indicator]: unit[indicator]
+      });
+      const response = await api.post(resolvedUrl, {
+        ...options2,
+        body: options2?.body ?? resolvedSchema.values
+      });
+      setMemorizedUnit(response);
+      patchEndpointMemoryTo(Endpoint.POST_UNIT, {
+        status: EndpointStatus.SUCCESS
+      });
+      return response;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.POST_UNIT, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  async function postUnits(units, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.POST_UNITS);
+    const body = units.map((unit) => {
+      const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+      if (options2?.validate) {
+        schema.pick(resolvedSchema.keys).parse(unit);
+      }
+      return resolvedSchema.values;
+    });
+    patchEndpointMemoryTo(Endpoint.POST_UNITS, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url);
+      const response = await api.post(resolvedUrl, {
+        ...options2,
+        body: options2?.body ?? body
+      });
+      setMemorizedUnits([
+        ...memorizedUnits.value,
+        ...response
+      ]);
+      patchEndpointMemoryTo(Endpoint.POST_UNITS, {
+        status: EndpointStatus.SUCCESS
+      });
+      return response;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.POST_UNITS, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  async function putUnit(unit, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNIT);
+    const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+    if (options2?.validate) {
+      schema.pick(resolvedSchema.keys).parse(unit);
+    }
+    patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
+        [indicator]: unit[indicator]
+      });
+      const response = await api.put(resolvedUrl, {
+        ...options2,
+        body: options2?.body ?? resolvedSchema.values
+      });
+      setMemorizedUnit(response);
+      patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
+        status: EndpointStatus.SUCCESS
+      });
+      return response;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.PUT_UNIT, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  async function putUnits(units, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.PUT_UNITS);
+    const body = units.map((unit) => {
+      const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+      if (options2?.validate) {
+        schema.pick(resolvedSchema.keys).parse(unit);
+      }
+      return resolvedSchema.values;
+    });
+    patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url);
+      const response = await api.put(resolvedUrl, {
+        ...options2,
+        body: options2?.body ?? body
+      });
+      setMemorizedUnits(response);
+      patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
+        status: EndpointStatus.SUCCESS
+      });
+      return response;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.PUT_UNITS, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  async function patchUnit(unit, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNIT);
+    const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+    if (options2?.validate) {
+      schema.pick(resolvedSchema.keys).partial().parse(unit);
+    }
+    patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
+        [indicator]: unit[indicator]
+      });
+      const response = await api.patch(
+        resolvedUrl,
+        {
+          ...options2,
+          body: options2?.body ?? resolvedSchema.values
+        }
+      );
+      editMemorizedUnit(response);
+      patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
+        status: EndpointStatus.SUCCESS
+      });
+      return response;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.PATCH_UNIT, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  async function patchUnits(units, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.PATCH_UNITS);
+    const body = units.map((unit) => {
+      const resolvedSchema = resolveSchema(schema, endpoint.action, unit);
+      if (options2?.validate) {
+        schema.pick(resolvedSchema.keys).partial().parse(unit);
+      }
+      return resolvedSchema.values;
+    });
+    patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url);
+      const response = await api.patch(resolvedUrl, {
+        ...options2,
+        body: options2?.body ?? body
+      });
+      editMemorizedUnits(response);
+      patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
+        status: EndpointStatus.SUCCESS
+      });
+      return response;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.PATCH_UNITS, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  async function deleteUnit(unit, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNIT);
+    patchEndpointMemoryTo(Endpoint.DELETE_UNIT, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url, {
+        [indicator]: unit[indicator]
+      });
+      await api.del(
+        resolvedUrl,
+        options2
+      );
+      dropMemorizedUnit(unit);
+      patchEndpointMemoryTo(Endpoint.DELETE_UNIT, {
+        status: EndpointStatus.SUCCESS
+      });
+      return true;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.DELETE_UNIT, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  async function deleteUnits(units, options2) {
+    const endpoint = getEndpoint(endpoints, Endpoint.DELETE_UNITS);
+    patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
+      status: EndpointStatus.PENDING
+    });
+    try {
+      const resolvedUrl = resolveEndpointUrl(endpoint.url);
+      await api.del(
+        resolvedUrl,
+        options2
+      );
+      dropMemorizedUnits(units);
+      patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
+        status: EndpointStatus.SUCCESS
+      });
+      return true;
+    } catch (error) {
+      patchEndpointMemoryTo(Endpoint.DELETE_UNITS, {
+        status: EndpointStatus.FAILED
+      });
+      throw error;
+    }
+  }
+  return {
+    api,
+    store,
+    memorizedUnit,
+    memorizedUnits,
+    hasMemorizedUnits,
+    endpointsStatus,
+    setMemorizedUnit,
+    setMemorizedUnits,
+    editMemorizedUnit,
+    editMemorizedUnits,
+    dropMemorizedUnit,
+    dropMemorizedUnits,
+    patchEndpointMemory,
+    purgeEndpointMemory,
+    getUnit,
+    getUnits,
+    postUnit,
+    postUnits,
+    putUnit,
+    putUnits,
+    patchUnit,
+    patchUnits,
+    deleteUnit,
+    deleteUnits
+  };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export { z } from "zod";
+export { ApiAction, ApiResponseType, ApiErrorSource, type ApiRequestHeader, type ApiRequestQuery, type ApiRequestBody, type ApiRequestOptions, type ApiOptions, type ApiActionOptions, type ApiErrorOptions, createApi, ApiError, ApiRequestError, ApiResponseError, } from "./core/api.js";
+export { Endpoint, EndpointStatus, type EndpointDefinition, type EndpointMemory, } from "./utils/endpoint.js";
+export { type SchemaMeta, getMeta, resolveSchema } from "./utils/schema.js";
+export { createStore } from "./core/store.js";

package/dist/runtime/index.js

@@ -0,0 +1,16 @@
+export { z } from "zod";
+export {
+  ApiAction,
+  ApiResponseType,
+  ApiErrorSource,
+  createApi,
+  ApiError,
+  ApiRequestError,
+  ApiResponseError
+} from "./core/api.js";
+export {
+  Endpoint,
+  EndpointStatus
+} from "./utils/endpoint.js";
+export { getMeta, resolveSchema } from "./utils/schema.js";
+export { createStore } from "./core/store.js";

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,20 @@
+import { createVuePlugin } from "@harlem/core";
+import {
+  createClientSSRPlugin,
+  createServerSSRPlugin
+} from "@harlem/plugin-ssr";
+export default defineNuxtPlugin((nuxtApp) => {
+  const plugins = [];
+  if (nuxtApp.payload.serverRendered) {
+    if (import.meta.server) {
+      plugins.push(createServerSSRPlugin());
+    }
+    if (import.meta.client) {
+      plugins.push(createClientSSRPlugin());
+    }
+  }
+  const harlem = createVuePlugin({
+    plugins
+  });
+  nuxtApp.vueApp.use(harlem);
+});

package/dist/runtime/utils/endpoint.d.ts

@@ -0,0 +1,72 @@
+import type { BaseState } from "@harlem/core";
+import type { ApiAction } from "../core/api.js";
+export declare enum Endpoint {
+    GET_UNIT = "getUnit",
+    GET_UNITS = "getUnits",
+    POST_UNIT = "postUnit",
+    POST_UNITS = "postUnits",
+    PUT_UNIT = "putUnit",
+    PUT_UNITS = "putUnits",
+    PATCH_UNIT = "patchUnit",
+    PATCH_UNITS = "patchUnits",
+    DELETE_UNIT = "deleteUnit",
+    DELETE_UNITS = "deleteUnits"
+}
+export declare enum EndpointStatus {
+    IDLE = "idle",
+    PENDING = "pending",
+    SUCCESS = "success",
+    FAILED = "failed"
+}
+export interface EndpointDefinition {
+    action: ApiAction;
+    url: string | ((keys: Record<PropertyKey, unknown>) => string);
+}
+export interface EndpointMemory {
+    status: EndpointStatus;
+}
+export declare function makeEndpointStatusKey<K extends Endpoint, S extends EndpointStatus>(key: K, status: S): `${K}Is${Capitalize<S>}`;
+export declare function getEndpoint(endpoints: Partial<Record<Endpoint, EndpointDefinition>> | undefined, key: Endpoint): EndpointDefinition;
+export declare function resolveEndpointUrl<T extends Record<PropertyKey, unknown>>(url: string | ((parameters: T) => string), parameters?: T): string;
+export declare function makeEndpointsStatus<T>(getter: (name: string, fn: (state: BaseState) => boolean) => T): {
+    getUnitIsIdle: T;
+    getUnitIsPending: T;
+    getUnitIsSuccess: T;
+    getUnitIsFailed: T;
+    getUnitsIsIdle: T;
+    getUnitsIsPending: T;
+    getUnitsIsSuccess: T;
+    getUnitsIsFailed: T;
+    postUnitIsIdle: T;
+    postUnitIsPending: T;
+    postUnitIsSuccess: T;
+    postUnitIsFailed: T;
+    postUnitsIsIdle: T;
+    postUnitsIsPending: T;
+    postUnitsIsSuccess: T;
+    postUnitsIsFailed: T;
+    putUnitIsIdle: T;
+    putUnitIsPending: T;
+    putUnitIsSuccess: T;
+    putUnitIsFailed: T;
+    putUnitsIsIdle: T;
+    putUnitsIsPending: T;
+    putUnitsIsSuccess: T;
+    putUnitsIsFailed: T;
+    patchUnitIsIdle: T;
+    patchUnitIsPending: T;
+    patchUnitIsSuccess: T;
+    patchUnitIsFailed: T;
+    patchUnitsIsIdle: T;
+    patchUnitsIsPending: T;
+    patchUnitsIsSuccess: T;
+    patchUnitsIsFailed: T;
+    deleteUnitIsIdle: T;
+    deleteUnitIsPending: T;
+    deleteUnitIsSuccess: T;
+    deleteUnitIsFailed: T;
+    deleteUnitsIsIdle: T;
+    deleteUnitsIsPending: T;
+    deleteUnitsIsSuccess: T;
+    deleteUnitsIsFailed: T;
+};

package/dist/runtime/utils/endpoint.js

@@ -0,0 +1,48 @@
+export var Endpoint = /* @__PURE__ */ ((Endpoint2) => {
+  Endpoint2["GET_UNIT"] = "getUnit";
+  Endpoint2["GET_UNITS"] = "getUnits";
+  Endpoint2["POST_UNIT"] = "postUnit";
+  Endpoint2["POST_UNITS"] = "postUnits";
+  Endpoint2["PUT_UNIT"] = "putUnit";
+  Endpoint2["PUT_UNITS"] = "putUnits";
+  Endpoint2["PATCH_UNIT"] = "patchUnit";
+  Endpoint2["PATCH_UNITS"] = "patchUnits";
+  Endpoint2["DELETE_UNIT"] = "deleteUnit";
+  Endpoint2["DELETE_UNITS"] = "deleteUnits";
+  return Endpoint2;
+})(Endpoint || {});
+export var EndpointStatus = /* @__PURE__ */ ((EndpointStatus2) => {
+  EndpointStatus2["IDLE"] = "idle";
+  EndpointStatus2["PENDING"] = "pending";
+  EndpointStatus2["SUCCESS"] = "success";
+  EndpointStatus2["FAILED"] = "failed";
+  return EndpointStatus2;
+})(EndpointStatus || {});
+export function makeEndpointStatusKey(key, status) {
+  return `${key}Is${status.charAt(0).toUpperCase() + status.slice(1)}`;
+}
+export function getEndpoint(endpoints, key) {
+  const endpoint = endpoints?.[key];
+  if (!endpoint) {
+    throw new Error(`Endpoint "${key}" is not configured`);
+  }
+  return endpoint;
+}
+export function resolveEndpointUrl(url, parameters = {}) {
+  if (typeof url === "function") {
+    return url(parameters);
+  }
+  return url;
+}
+export function makeEndpointsStatus(getter) {
+  const output = {};
+  for (const key of Object.values(Endpoint)) {
+    for (const status of Object.values(EndpointStatus)) {
+      const statusKey = makeEndpointStatusKey(key, status);
+      output[statusKey] = getter(statusKey, (state) => {
+        return state.endpoints[key]?.status === status;
+      });
+    }
+  }
+  return output;
+}

package/dist/runtime/utils/schema.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import type { ApiAction } from "../core/api.js";
+export interface SchemaMeta {
+    indicator?: boolean;
+    actions?: ApiAction[];
+}
+export declare function getMeta(field: any): SchemaMeta | undefined;
+export declare function resolveSchema<T extends z.ZodRawShape, S extends z.infer<z.ZodObject<T>>>(schema: z.ZodObject<T>, action?: ApiAction, input?: Partial<S>): {
+    indicator: keyof S;
+    keys: Record<keyof S, true>;
+    values: Partial<S>;
+};

package/dist/runtime/utils/schema.js

@@ -0,0 +1,26 @@
+export function getMeta(field) {
+  return field.meta();
+}
+export function resolveSchema(schema, action, input) {
+  const output = {
+    indicator: "id",
+    keys: {},
+    values: {}
+  };
+  for (const key of Object.keys(schema.shape)) {
+    const meta = getMeta(schema.shape[key]);
+    if (meta?.indicator) {
+      output.indicator = key;
+    }
+    if (!action || !meta?.actions) {
+      continue;
+    }
+    if (meta?.actions.includes(action)) {
+      output.keys[key] = true;
+      if (input && key in input) {
+        output.values[key] = input[key];
+      }
+    }
+  }
+  return output;
+}

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.js'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module'

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@diphyx/harlemify",
+  "version": "0.0.1",
+  "description": "API state management for Nuxt powered by Harlem",
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "harlem",
+    "state-management",
+    "api",
+    "zod",
+    "vue",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/diphyx/harlemify.git"
+  },
+  "homepage": "https://diphyx.github.io/harlemify/",
+  "bugs": {
+    "url": "https://github.com/diphyx/harlemify/issues"
+  },
+  "license": "MIT",
+  "author": "Amir Reza Dalir",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "module": "./dist/module.mjs",
+  "types": "./dist/types.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nuxt/kit": "^3.14.0",
+    "@harlem/core": "^3.0.0",
+    "@harlem/plugin-ssr": "^3.0.0",
+    "defu": "^6.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^1.6.0",
+    "@nuxt/eslint-config": "^0.6.0",
+    "@nuxt/module-builder": "^0.8.0",
+    "@nuxt/schema": "^3.14.0",
+    "@nuxt/test-utils": "^3.14.0",
+    "@types/node": "^22.0.0",
+    "eslint": "^9.0.0",
+    "nuxt": "^3.14.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.0.0"
+  },
+  "scripts": {
+    "postinstall": "nuxi prepare playground",
+    "build": "nuxt-module-build build",
+    "dev": "nuxi dev playground",
+    "lint": "eslint . --fix",
+    "test": "vitest run"
+  }
+}