@diphyx/harlemify 5.3.0 → 5.4.0

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

@@ -1,77 +1,14 @@
 import { defu } from "defu";
 import { z } from "zod";
 import { isPlainObject, isEmptyRecord } from "./base.js";
-function resolveStringZeroValue() {
-  return "";
-}
-function resolveNumberZeroValue() {
-  return 0;
-}
-function resolveBooleanZeroValue() {
-  return false;
-}
-function resolveBigintZeroValue() {
-  return BigInt(0);
-}
-function resolveDateZeroValue() {
-  return /* @__PURE__ */ new Date(0);
-}
-function resolveArrayZeroValue() {
-  return [];
-}
-function resolveRecordZeroValue() {
-  return {};
-}
-function resolveMapZeroValue() {
-  return /* @__PURE__ */ new Map();
-}
-function resolveSetZeroValue() {
-  return /* @__PURE__ */ new Set();
-}
-function resolveObjectZeroValue(definition) {
-  const output = {};
-  if (definition.shape) {
-    for (const [key, value] of Object.entries(definition.shape)) {
-      output[key] = resolveZeroValue(value);
-    }
-  }
-  return output;
-}
-function resolveEnumZeroValue(definition) {
-  if (definition.entries) {
-    return Object.values(definition.entries)[0];
-  }
-  return void 0;
-}
-function resolveLiteralZeroValue(definition) {
-  if (definition.values) {
-    return definition.values[0];
-  }
-  return void 0;
-}
-function resolveTupleZeroValue(definition) {
-  if (definition.items) {
-    return definition.items.map(resolveZeroValue);
-  }
-  return [];
-}
-function resolveUnionZeroValue(definition) {
-  if (definition.options?.[0]) {
-    return resolveZeroValue(definition.options[0]);
-  }
-  return void 0;
-}
-function resolveDefaultZeroValue(definition) {
-  if (typeof definition.defaultValue === "function") {
-    return definition.defaultValue();
+function resolveShapeFields(shape) {
+  if (!("shape" in shape) || typeof shape.shape !== "object" || !shape.shape) {
+    return void 0;
   }
-  return definition.defaultValue;
+  return shape.shape;
 }
-function resolveInnerZeroValue(definition) {
-  if (definition.innerType) {
-    return resolveZeroValue(definition.innerType);
-  }
-  return void 0;
+function resolveFieldMeta(field) {
+  return field?.meta?.();
 }
 function resolveZeroValue(field) {
   const definition = field.def;
@@ -80,93 +17,83 @@ function resolveZeroValue(field) {
   }
   switch (definition.type) {
     case "string": {
-      return resolveStringZeroValue();
+      return "";
     }
     case "number": {
-      return resolveNumberZeroValue();
+      return 0;
     }
     case "boolean": {
-      return resolveBooleanZeroValue();
+      return false;
     }
     case "bigint": {
-      return resolveBigintZeroValue();
+      return BigInt(0);
     }
     case "date": {
-      return resolveDateZeroValue();
+      return /* @__PURE__ */ new Date(0);
     }
     case "array": {
-      return resolveArrayZeroValue();
+      return [];
     }
     case "record": {
-      return resolveRecordZeroValue();
+      return {};
     }
     case "map": {
-      return resolveMapZeroValue();
+      return /* @__PURE__ */ new Map();
     }
     case "set": {
-      return resolveSetZeroValue();
+      return /* @__PURE__ */ new Set();
     }
     case "object": {
-      return resolveObjectZeroValue(definition);
+      const output = {};
+      if (definition.shape) {
+        for (const [key, value] of Object.entries(definition.shape)) {
+          output[key] = resolveZeroValue(value);
+        }
+      }
+      return output;
     }
     case "enum": {
-      return resolveEnumZeroValue(definition);
+      if (definition.entries) {
+        return Object.values(definition.entries)[0];
+      }
+      return void 0;
     }
     case "literal": {
-      return resolveLiteralZeroValue(definition);
+      if (definition.values) {
+        return definition.values[0];
+      }
+      return void 0;
     }
     case "tuple": {
-      return resolveTupleZeroValue(definition);
+      if (definition.items) {
+        return definition.items.map(resolveZeroValue);
+      }
+      return [];
     }
     case "union": {
-      return resolveUnionZeroValue(definition);
+      if (definition.options?.[0]) {
+        return resolveZeroValue(definition.options[0]);
+      }
+      return void 0;
     }
     case "default": {
-      return resolveDefaultZeroValue(definition);
+      if (typeof definition.defaultValue === "function") {
+        return definition.defaultValue();
+      }
+      return definition.defaultValue;
     }
     case "optional":
     case "nullable": {
-      return resolveInnerZeroValue(definition);
+      if (definition.innerType) {
+        return resolveZeroValue(definition.innerType);
+      }
+      return void 0;
     }
     default: {
       return void 0;
     }
   }
 }
-export function resolveShape(shape) {
-  const resolved = {
-    identifier: void 0,
-    defaults: {},
-    fields: [],
-    aliases: {}
-  };
-  for (const [key, field] of Object.entries(shape.shape)) {
-    resolved.fields.push(key);
-    const fieldMeta = field.meta();
-    if (fieldMeta?.identifier) {
-      resolved.identifier = key;
-    }
-    if (fieldMeta?.alias) {
-      resolved.aliases[key] = fieldMeta.alias;
-    }
-    const fieldDefinition = field.def;
-    if (fieldDefinition?.defaultValue !== void 0) {
-      if (typeof fieldDefinition.defaultValue === "function") {
-        resolved.defaults[key] = fieldDefinition.defaultValue();
-        continue;
-      }
-      resolved.defaults[key] = fieldDefinition.defaultValue;
-    }
-  }
-  if (!resolved.identifier) {
-    if (resolved.fields.includes("id")) {
-      resolved.identifier = "id";
-    } else if (resolved.fields.includes("_id")) {
-      resolved.identifier = "_id";
-    }
-  }
-  return resolved;
-}
 function resolveAliasObject(data, mapping) {
   const output = {};
   for (const [key, value] of Object.entries(data)) {
@@ -212,21 +139,54 @@ export function resolveAliasOutbound(data, aliases) {
   }
   return data;
 }
-export function resolveDefaults(shape, overrides) {
+export function resolveShapeIdentifier(shape, ...overrides) {
+  for (const key of overrides) {
+    if (key) {
+      return key;
+    }
+  }
+  const fields = resolveShapeFields(shape);
+  if (!fields) {
+    return "id";
+  }
+  for (const [key, field] of Object.entries(fields)) {
+    const meta = resolveFieldMeta(field);
+    if (meta?.identifier) {
+      return key;
+    }
+  }
+  return "id";
+}
+export function resolveShapeAliases(shape) {
+  const output = {};
+  const fields = resolveShapeFields(shape);
+  if (!fields) {
+    return output;
+  }
+  for (const [key, field] of Object.entries(fields)) {
+    const meta = resolveFieldMeta(field);
+    if (meta?.alias) {
+      output[key] = meta.alias;
+    }
+  }
+  return output;
+}
+export function resolveZeroValues(shape) {
   const output = {};
   for (const [key, field] of Object.entries(shape.shape)) {
     output[key] = resolveZeroValue(field);
   }
-  if (overrides) {
-    return defu(overrides, output);
-  }
   return output;
 }
 export function createShape(definition) {
   const object = z.object(definition);
   const shape = Object.assign(object, {
     defaults(overrides) {
-      return resolveDefaults(object, overrides);
+      const zero = resolveZeroValues(object);
+      if (overrides) {
+        return defu(overrides, zero);
+      }
+      return zero;
     }
   });
   return shape;

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

@@ -1,5 +1,5 @@
 import type { createStore as createSourceStore } from "@harlem/core";
-import { type ModelDefinitions, type ModelDefinitionsInfer, type StoreModel } from "../types/model.js";
+import type { ModelDefinitions, ModelDefinitionsInfer, StoreModel } from "../types/model.js";
 import type { ViewDefinitions, StoreView } from "../types/view.js";
 import type { ActionDefinition, ActionDefinitions, StoreAction } from "../types/action.js";
 export declare function createStoreState<MD extends ModelDefinitions>(modelDefinitions: MD): ModelDefinitionsInfer<MD>;

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

@@ -1,19 +1,10 @@
 import { createModel } from "./model.js";
 import { createView } from "./view.js";
 import { createAction } from "./action.js";
-import {
-  ModelType,
-  ModelManyKind
-} from "../types/model.js";
 export function createStoreState(modelDefinitions) {
   const output = {};
-  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;
-    }
+  for (const [key, definition] of Object.entries(modelDefinitions)) {
+    output[key] = definition.default();
   }
   return output;
 }

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

@@ -1,6 +1,6 @@
 import { ViewClone } from "../types/view.js";
 function resolveClonedValue(definition, value) {
-  if (!definition.options?.clone || value === null || value === void 0) {
+  if (!definition.options?.clone) {
     return value;
   }
   if (definition.options.clone === ViewClone.DEEP) {

package/dist/runtime/index.d.ts

@@ -2,13 +2,16 @@ 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 { ModelType, ModelManyKind, ModelOneMode, ModelManyMode } from "./core/types/model.js";
+export { ModelType, ModelManyKind, ModelOneMode, ModelManyMode, ModelSilent } 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, 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 type { ComposeCallback, ComposeCall, ComposeDefinitions, ComposeContext, StoreCompose, } from "./core/types/compose.js";
+export { useStoreCompose } from "./composables/compose.js";
+export type { UseStoreCompose } from "./composables/compose.js";
 export { useIsolatedActionStatus, useIsolatedActionError, useStoreAction } from "./composables/action.js";
 export type { UseStoreActionOptions, UseStoreAction } from "./composables/action.js";
 export { useStoreModel } from "./composables/model.js";

package/dist/runtime/index.js

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

package/dist/runtime/plugin.js

@@ -1,23 +1,9 @@
 import { createVuePlugin } from "@harlem/core";
-import { createServerSSRPlugin, createClientSSRPlugin, getBridgingScript } from "@harlem/plugin-ssr";
-import { defineNuxtPlugin, useHead } from "#imports";
+import { defineNuxtPlugin } from "#imports";
+import { createServerSideRenderingPlugin } from "./plugins/ssr.js";
 export default defineNuxtPlugin((nuxtApp) => {
-  const plugins = [];
-  if (import.meta.server) {
-    plugins.push(createServerSSRPlugin());
-  }
-  if (import.meta.client && window["__harlemState"]) {
-    plugins.push(createClientSSRPlugin());
-  }
   const harlem = createVuePlugin({
-    plugins
+    plugins: [createServerSideRenderingPlugin(nuxtApp)]
   });
   nuxtApp.vueApp.use(harlem);
-  useHead({
-    script: [
-      {
-        innerHTML: getBridgingScript()
-      }
-    ]
-  });
 });

package/dist/runtime/plugins/ssr.d.ts

@@ -0,0 +1,9 @@
+import type { HarlemPlugin } from "@harlem/core";
+interface ServerSideRenderingContext {
+    hooks: {
+        hook: (name: "app:rendered", fn: () => void) => void;
+    };
+    payload: Record<string, unknown>;
+}
+export declare function createServerSideRenderingPlugin(nuxtApp: ServerSideRenderingContext): HarlemPlugin;
+export {};

package/dist/runtime/plugins/ssr.js

@@ -0,0 +1,53 @@
+function handleServer(nuxtApp, stores) {
+  for (const store of stores.values()) {
+    const mutations = store.registrations["mutations"];
+    if (!mutations) {
+      continue;
+    }
+    for (const [name, registration] of mutations) {
+      if (!name.endsWith(":reset")) {
+        continue;
+      }
+      registration.producer()({});
+    }
+  }
+  nuxtApp.hooks.hook("app:rendered", () => {
+    const snapshot = {};
+    for (const store of stores.values()) {
+      snapshot[store.name] = store.state;
+    }
+    nuxtApp.payload.harlemifyState = snapshot;
+  });
+}
+function handleClient(nuxtApp, eventEmitter, stores) {
+  const harlemifyState = nuxtApp.payload.harlemifyState;
+  if (!harlemifyState) {
+    return;
+  }
+  eventEmitter.on("ssr:init:client", (payload) => {
+    if (!payload) {
+      return;
+    }
+    const store = stores.get(payload.store);
+    if (!store) {
+      return;
+    }
+    const snapshot = harlemifyState[store.name];
+    if (!snapshot) {
+      return;
+    }
+    store.write("harlemify:ssr:init", "harlemify", (state) => {
+      Object.assign(state, snapshot);
+    });
+  });
+}
+export function createServerSideRenderingPlugin(nuxtApp) {
+  return (app, eventEmitter, stores) => {
+    if (import.meta.server) {
+      handleServer(nuxtApp, stores);
+    }
+    if (import.meta.client) {
+      handleClient(nuxtApp, eventEmitter, stores);
+    }
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diphyx/harlemify",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "API state management for Nuxt powered by Harlem",
   "keywords": [
     "nuxt",
@@ -41,26 +41,25 @@
     "dist"
   ],
   "dependencies": {
-    "@harlem/core": "^3.0.0",
-    "@harlem/plugin-ssr": "^3.0.0",
-    "@nuxt/kit": "^3.14.0",
-    "consola": "^3.0.0",
-    "defu": "^6.0.0",
-    "zod": "^4.0.0"
+    "@harlem/core": "^3.1.8",
+    "@nuxt/kit": "^3.14.0 || ^4.0.0",
+    "consola": "^3.4.2",
+    "defu": "^6.1.4",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@nuxt/eslint-config": "^0.6.0",
-    "@nuxt/module-builder": "^0.8.0",
-    "@nuxt/schema": "^3.14.0",
-    "@nuxt/test-utils": "^3.14.0",
-    "@playwright/test": "^1.50.0",
-    "@types/node": "^22.0.0",
+    "@nuxt/eslint-config": "^0.6.2",
+    "@nuxt/module-builder": "^0.8.4",
+    "@nuxt/schema": "^4.3.1",
+    "@nuxt/test-utils": "^3.23.0",
+    "@playwright/test": "^1.58.2",
+    "@types/node": "^22.19.11",
     "@vitest/coverage-v8": "^2.1.9",
-    "eslint": "^9.0.0",
-    "nuxt": "^3.14.0",
-    "typescript": "^5.6.0",
-    "vitest": "^2.0.0",
-    "vue": "^3.5.26"
+    "eslint": "^9.39.2",
+    "nuxt": "^4.3.1",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.9",
+    "vue": "^3.5.28"
   },
   "scripts": {
     "cleanup": "pnpm nuxt cleanup && pnpm nuxt cleanup playground",