@holo-js/adapter-nuxt 0.2.6 → 0.3.0

package/dist/module.d.mts

@@ -42,6 +42,12 @@ type HoloStorageRuntimeConfig = {
     routePrefix: string;
     disks: Record<string, RuntimeDiskConfig>;
 };
+type StorageModule = {
+    applyNitroStorageConfig(nitro: NuxtOptionsWithNitro, config: HoloStorageRuntimeConfig, s3Driver: string): void;
+    hasPublicLocalDisk(config: HoloStorageRuntimeConfig): boolean;
+    mergeModuleOptions(base: StorageModuleOptions | undefined, overrides: StorageModuleOptions | undefined): StorageModuleOptions;
+    normalizeModuleOptions(options: StorageModuleOptions | undefined): HoloStorageRuntimeConfig;
+};
 type StorageS3Module = {
     default: unknown;
 };
@@ -92,11 +98,27 @@ interface NuxtOptionsWithNitro {
     _holoCoreRuntimeRegistered?: boolean;
     _holoTypesRegistered?: boolean;
 }
+declare function hasProjectPackage(rootDir: string, packageName: string, resolvePackage?: (packageName: string) => string): boolean;
 declare function resolveClientOptimizeDeps(rootDir: string): string[];
 declare function addViteOptimizeDeps(opts: NuxtOptionsWithNitro, deps: readonly string[]): void;
+declare function isRealtimeDefinitionModule(_rootDir: string, id: string): boolean;
+declare function resolveExistingRealtimeDefinitionFile(path: string): string | undefined;
+declare function existsFile(path: string): boolean;
+declare function resolveRealtimeDefinitionImport(source: string, importer: string | undefined): string | undefined;
+declare function createRealtimeDefinitionVitePlugin(rootDir: string): unknown;
+declare function addVitePlugin(vite: NuxtViteOptions, plugin: unknown): void;
+declare function addNitroErrorHandler(opts: NuxtOptionsWithNitro, handler: string): void;
 declare function importOptionalStorageS3Module(): Promise<StorageS3Module | undefined>;
 declare function hasLoadedConfigFile(loaded: LoadedHoloConfig<HoloConfigMap>, configName: string): boolean;
 declare function toStorageModuleOptions(loaded: LoadedHoloConfig<HoloConfigMap>): StorageModuleOptions;
+declare function resolveStorageSetup(storageModule: StorageModule | undefined, loaded: LoadedHoloConfig<HoloConfigMap>): {
+    readonly options: StorageModuleOptions | undefined;
+    readonly normalized: HoloStorageRuntimeConfig | undefined;
+};
+declare function finalizeStorageSetup(storageModule: StorageModule, opts: NuxtOptionsWithNitro, resolver: {
+    resolve(path: string): string;
+}, s3Driver: string): void;
+declare function applyStorageRuntimeConfig(runtimeConfig: Record<string, unknown>, normalized: HoloStorageRuntimeConfig | undefined): void;
 declare const _default: {
     meta?: {
         name?: string;
@@ -107,11 +129,22 @@ declare const _default: {
 
 declare const moduleInternals: {
     addViteOptimizeDeps: typeof addViteOptimizeDeps;
+    addVitePlugin: typeof addVitePlugin;
+    addNitroErrorHandler: typeof addNitroErrorHandler;
+    createRealtimeDefinitionVitePlugin: typeof createRealtimeDefinitionVitePlugin;
+    existsFile: typeof existsFile;
+    hasProjectPackage: typeof hasProjectPackage;
     hasModuleNotFoundCode: typeof hasModuleNotFoundCode;
     hasLoadedConfigFile: typeof hasLoadedConfigFile;
     importOptionalStorageS3Module: typeof importOptionalStorageS3Module;
+    applyStorageRuntimeConfig: typeof applyStorageRuntimeConfig;
+    finalizeStorageSetup: typeof finalizeStorageSetup;
+    resolveStorageSetup: typeof resolveStorageSetup;
     isModuleResolutionFailure: typeof isModuleResolutionFailure;
+    isRealtimeDefinitionModule: typeof isRealtimeDefinitionModule;
     resolveClientOptimizeDeps: typeof resolveClientOptimizeDeps;
+    resolveExistingRealtimeDefinitionFile: typeof resolveExistingRealtimeDefinitionFile;
+    resolveRealtimeDefinitionImport: typeof resolveRealtimeDefinitionImport;
 };
 declare const adapterNuxtInternals: {
     toStorageModuleOptions: typeof toStorageModuleOptions;

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@holo-js/adapter-nuxt",
   "configKey": "@holo-js/adapter-nuxt",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -4,246 +4,14 @@ import { createRequire } from 'node:module';
 import { resolve, extname, relative, basename, dirname } from 'node:path';
 import { defineNuxtModule, createResolver, addServerPlugin, addServerImportsDir, addServerHandler, addPlugin } from '@nuxt/kit';
 import { loadConfigDirectory } from '@holo-js/config';
+import '@holo-js/db/config';
+import { createRealtimeClientDefinitionTransform as createRealtimeClientDefinitionTransform$1, createRealtimeClientDefinitionModule as createRealtimeClientDefinitionModule$1 } from '@holo-js/adapter-shared';
 
-const serverOnlyRealtimeProperties = /* @__PURE__ */ new Set(["handler", "authorize"]);
-function isIdentifierBoundary(value) {
-  return !value || !/[$\w]/.test(value);
-}
-function skipString(source, index, quote) {
-  let cursor = index + 1;
-  while (cursor < source.length) {
-    const char = source[cursor];
-    if (char === "\\") {
-      cursor += 2;
-      continue;
-    }
-    if (char === quote) {
-      return cursor + 1;
-    }
-    cursor += 1;
-  }
-  return cursor;
-}
-function skipLineComment(source, index) {
-  const end = source.indexOf("\n", index + 2);
-  return end === -1 ? source.length : end + 1;
-}
-function skipBlockComment(source, index) {
-  const end = source.indexOf("*/", index + 2);
-  return end === -1 ? source.length : end + 2;
-}
-function skipSyntax(source, index) {
-  const char = source[index];
-  const next = source[index + 1];
-  if (char === '"' || char === "'" || char === "`") {
-    return skipString(source, index, char);
-  }
-  if (char === "/" && next === "/") {
-    return skipLineComment(source, index);
-  }
-  if (char === "/" && next === "*") {
-    return skipBlockComment(source, index);
-  }
-  return void 0;
-}
-function findRealtimePropertyValueEnd(source, index) {
-  let cursor = index;
-  let braceDepth = 0;
-  let bracketDepth = 0;
-  let parenDepth = 0;
-  while (cursor < source.length) {
-    const syntaxEnd = skipSyntax(source, cursor);
-    if (typeof syntaxEnd === "number") {
-      cursor = syntaxEnd;
-      continue;
-    }
-    const char = source[cursor];
-    if (char === "{") {
-      braceDepth += 1;
-    } else if (char === "}") {
-      if (braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
-        return cursor;
-      }
-      braceDepth -= 1;
-    } else if (char === "[") {
-      bracketDepth += 1;
-    } else if (char === "]") {
-      bracketDepth -= 1;
-    } else if (char === "(") {
-      parenDepth += 1;
-    } else if (char === ")") {
-      parenDepth -= 1;
-    } else if (char === "," && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
-      return cursor;
-    }
-    cursor += 1;
-  }
-  return source.length;
-}
-function findClosingBrace(source, index) {
-  let cursor = index;
-  let depth = 0;
-  while (cursor < source.length) {
-    const syntaxEnd = skipSyntax(source, cursor);
-    if (typeof syntaxEnd === "number") {
-      cursor = syntaxEnd;
-      continue;
-    }
-    const char = source[cursor];
-    if (char === "{") {
-      depth += 1;
-    } else if (char === "}") {
-      depth -= 1;
-      if (depth === 0) {
-        return cursor;
-      }
-    }
-    cursor += 1;
-  }
-  return -1;
-}
-function applyReplacements(source, replacements) {
-  if (replacements.length === 0) {
-    return source;
-  }
-  let output = "";
-  let cursor = 0;
-  const ordered = [...replacements].sort((left, right) => left.start - right.start);
-  for (const replacement of ordered) {
-    output += source.slice(cursor, replacement.start);
-    output += replacement.text;
-    cursor = replacement.end;
-  }
-  return output + source.slice(cursor);
-}
-function extractObjectPropertyValue(objectSource, propertyName) {
-  let cursor = 1;
-  while (cursor < objectSource.length - 1) {
-    const syntaxEnd = skipSyntax(objectSource, cursor);
-    if (typeof syntaxEnd === "number") {
-      cursor = syntaxEnd;
-      continue;
-    }
-    const match = objectSource.slice(cursor).match(/^[$A-Z_a-z][$\w]*/);
-    const name = match?.[0];
-    if (!name || name !== propertyName) {
-      cursor += 1;
-      continue;
-    }
-    const afterName = cursor + name.length;
-    if (!isIdentifierBoundary(objectSource[cursor - 1]) || !isIdentifierBoundary(objectSource[afterName])) {
-      cursor += name.length;
-      continue;
-    }
-    let colon = afterName;
-    while (/\s/.test(objectSource[colon] ?? "")) {
-      colon += 1;
-    }
-    if (objectSource[colon] !== ":") {
-      cursor += name.length;
-      continue;
-    }
-    const valueStart = colon + 1;
-    const valueEnd = findRealtimePropertyValueEnd(objectSource, valueStart);
-    return objectSource.slice(valueStart, valueEnd).trim();
-  }
-  return void 0;
-}
-function collectRealtimeDefinitionExports(source) {
-  const definitions = [];
-  let cursor = 0;
-  while (cursor < source.length) {
-    const syntaxEnd = skipSyntax(source, cursor);
-    if (typeof syntaxEnd === "number") {
-      cursor = syntaxEnd;
-      continue;
-    }
-    const match = source.slice(cursor).match(/^export\s+const\s+([$A-Z_a-z][$\w]*)\s*=\s*(query|mutation)\s*\(/);
-    const exportedName = match?.[1];
-    const factoryName = match?.[2];
-    if (!exportedName || !factoryName) {
-      cursor += 1;
-      continue;
-    }
-    let objectStart = cursor + match[0].length;
-    while (/\s/.test(source[objectStart] ?? "")) {
-      objectStart += 1;
-    }
-    if (source[objectStart] !== "{") {
-      cursor += match[0].length;
-      continue;
-    }
-    const objectEnd = findClosingBrace(source, objectStart);
-    if (objectEnd === -1) {
-      cursor += match[0].length;
-      continue;
-    }
-    const objectSource = source.slice(objectStart, objectEnd + 1);
-    definitions.push({
-      exportedName,
-      factoryName,
-      nameValue: extractObjectPropertyValue(objectSource, "name")
-    });
-    cursor = objectEnd + 1;
-  }
-  return definitions;
-}
 function createRealtimeClientDefinitionModule(source) {
-  const definitions = collectRealtimeDefinitionExports(source);
-  if (definitions.length === 0) {
-    return stripRealtimeServerHandlers(source);
-  }
-  const factories = [...new Set(definitions.map((definition) => definition.factoryName))];
-  return [
-    `import { ${factories.join(", ")} } from '@holo-js/adapter-nuxt/realtime'`,
-    "",
-    ...definitions.flatMap((definition) => [
-      `export const ${definition.exportedName} = ${definition.factoryName}({`,
-      ...definition.nameValue ? [`  name: ${definition.nameValue},`] : [],
-      "  handler: undefined,",
-      "})",
-      ""
-    ])
-  ].join("\n");
+  return createRealtimeClientDefinitionModule$1(source, "@holo-js/adapter-nuxt/realtime");
 }
-function stripRealtimeServerHandlers(source) {
-  const replacements = [];
-  let cursor = 0;
-  while (cursor < source.length) {
-    const syntaxEnd = skipSyntax(source, cursor);
-    if (typeof syntaxEnd === "number") {
-      cursor = syntaxEnd;
-      continue;
-    }
-    const match = source.slice(cursor).match(/^[$A-Z_a-z][$\w]*/);
-    const name = match?.[0];
-    if (!name || !serverOnlyRealtimeProperties.has(name)) {
-      cursor += 1;
-      continue;
-    }
-    const afterName = cursor + name.length;
-    if (!isIdentifierBoundary(source[cursor - 1]) || !isIdentifierBoundary(source[afterName])) {
-      cursor += name.length;
-      continue;
-    }
-    let colon = afterName;
-    while (/\s/.test(source[colon] ?? "")) {
-      colon += 1;
-    }
-    if (source[colon] !== ":") {
-      cursor += name.length;
-      continue;
-    }
-    const valueStart = colon + 1;
-    const valueEnd = findRealtimePropertyValueEnd(source, valueStart);
-    replacements.push({
-      start: valueStart,
-      end: valueEnd,
-      text: " undefined"
-    });
-    cursor = valueEnd;
-  }
-  return applyReplacements(source, replacements);
+function createRealtimeClientDefinitionTransform(source) {
+  return createRealtimeClientDefinitionTransform$1(source, "@holo-js/adapter-nuxt/realtime");
 }
 
 const MODEL_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
@@ -289,10 +57,9 @@ function isModuleResolutionFailure(error) {
   }
   return "code" in error && (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_MODULE_NOT_FOUND");
 }
-function hasProjectPackage(rootDir, packageName) {
-  const projectRequire = createRequire(resolve(rootDir, "package.json"));
+function hasProjectPackage(rootDir, packageName, resolvePackage = createRequire(resolve(rootDir, "package.json")).resolve) {
   try {
-    projectRequire.resolve(packageName);
+    resolvePackage(packageName);
     return true;
   } catch (error) {
     if (isModuleResolutionFailure(error)) {
@@ -330,7 +97,8 @@ function addViteOptimizeDeps(opts, deps) {
   ];
 }
 function isRealtimeDefinitionModule(_rootDir, id) {
-  const normalizedId = id.split("?")[0]?.replaceAll("\\", "/") ?? "";
+  const [sourcePath = ""] = id.split("?");
+  const normalizedId = sourcePath.replaceAll("\\", "/");
   return normalizedId.includes("/server/realtime/") && MODEL_FILE_EXTENSIONS.has(extname(normalizedId));
 }
 function resolveExistingRealtimeDefinitionFile(path) {
@@ -356,7 +124,7 @@ function resolveRealtimeDefinitionImport(source, importer) {
   if (!source.includes("server/realtime") && !source.includes("server\\realtime")) {
     return void 0;
   }
-  const basePath = source.startsWith(".") ? importer ? resolve(dirname(importer.split("?")[0] ?? importer), source) : void 0 : resolve(source);
+  const basePath = source.startsWith(".") ? importer ? resolve(dirname(importer.split("?")[0]), source) : void 0 : resolve(source);
   return basePath ? resolveExistingRealtimeDefinitionFile(basePath) : void 0;
 }
 function createRealtimeDefinitionVitePlugin(rootDir) {
@@ -381,10 +149,7 @@ function createRealtimeDefinitionVitePlugin(rootDir) {
       if (options?.ssr || !isRealtimeDefinitionModule(rootDir, id)) {
         return null;
       }
-      return {
-        code: createRealtimeClientDefinitionModule(code),
-        map: null
-      };
+      return createRealtimeClientDefinitionTransform(code);
     }
   };
 }
@@ -441,6 +206,36 @@ function toStorageModuleOptions(loaded) {
     disks: { ...loaded.storage.disks }
   };
 }
+function resolveStorageSetup(storageModule, loaded) {
+  if (!storageModule) {
+    if (hasLoadedConfigFile(loaded, "storage")) {
+      throw new Error("[@holo-js/adapter-nuxt] Storage config requires @holo-js/storage to be installed.");
+    }
+    return { options: void 0, normalized: void 0 };
+  }
+  const options = storageModule.mergeModuleOptions(void 0, toStorageModuleOptions(loaded));
+  return {
+    options,
+    normalized: storageModule.normalizeModuleOptions(options)
+  };
+}
+function finalizeStorageSetup(storageModule, opts, resolver, s3Driver) {
+  const normalized = storageModule.normalizeModuleOptions(opts._holoStorageModuleOptions);
+  opts.runtimeConfig = opts.runtimeConfig || {};
+  opts.runtimeConfig.holoStorage = normalized;
+  storageModule.applyNitroStorageConfig(opts, normalized, s3Driver);
+  if (storageModule.hasPublicLocalDisk(normalized)) {
+    addServerHandler({
+      route: `${normalized.routePrefix}/**`,
+      handler: resolver.resolve("./runtime/server/routes/storage.get")
+    });
+  }
+}
+function applyStorageRuntimeConfig(runtimeConfig, normalized) {
+  if (normalized) {
+    runtimeConfig.holoStorage = normalized;
+  }
+}
 async function createServerModelImports(sourceDir, modelsRelativePath, generatedSchemaRelativePath) {
   const modelsDir = resolve(sourceDir, modelsRelativePath);
   const generatedSchemaPath = resolve(sourceDir, generatedSchemaRelativePath);
@@ -499,12 +294,12 @@ const module$1 = defineNuxtModule({
     const authorizationTypesPath = resolve(rootDir, ".holo-js/generated/authorization/types.d.ts");
     const modelRegistryTypesPath = resolve(rootDir, ".holo-js/generated/model-registry.d.ts");
     addViteOptimizeDeps(opts, resolveClientOptimizeDeps(rootDir));
+    const storageModule = await importOptionalStorageModule();
     const loaded = await loadConfigDirectory(rootDir, {
       preferCache: process.env.NODE_ENV === "production",
       processEnv: process.env
     });
-    const storageModule = await importOptionalStorageModule();
-    const loadedStorageOptions = toStorageModuleOptions(loaded);
+    const storageSetup = resolveStorageSetup(storageModule, loaded);
     const s3Driver = resolver.resolve("./runtime/drivers/s3.js");
     opts.nitro = opts.nitro || { storage: {} };
     opts.nitro.storage = opts.nitro.storage || {};
@@ -526,21 +321,15 @@ const module$1 = defineNuxtModule({
       projectRoot: rootDir
     };
     opts.runtimeConfig.db = loaded.database;
-    const storageConfigured = hasLoadedConfigFile(loaded, "storage");
-    if (!storageModule && storageConfigured) {
-      throw new Error("[@holo-js/adapter-nuxt] Storage config requires @holo-js/storage to be installed.");
-    }
-    const mergedStorageOptions = storageModule?.mergeModuleOptions(void 0, loadedStorageOptions);
-    const normalizedStorage = mergedStorageOptions ? storageModule?.normalizeModuleOptions(mergedStorageOptions) : void 0;
+    const mergedStorageOptions = storageSetup.options;
+    const normalizedStorage = storageSetup.normalized;
     opts._holoStorageModuleOptions = mergedStorageOptions;
     if (normalizedStorage && Object.values(normalizedStorage.disks).some((disk) => disk.driver === "s3")) {
       if (!await importOptionalStorageS3Module()) {
         throw new Error("[@holo-js/adapter-nuxt] S3 storage disks require @holo-js/storage-s3 to be installed.");
       }
     }
-    if (normalizedStorage) {
-      opts.runtimeConfig.holoStorage = normalizedStorage;
-    }
+    applyStorageRuntimeConfig(opts.runtimeConfig, normalizedStorage);
     if (!opts._holoCoreRuntimeRegistered) {
       addServerPlugin(resolver.resolve("./runtime/plugins/init"));
       addServerPlugin(resolver.resolve("./runtime/plugins/forms"));
@@ -597,16 +386,7 @@ const module$1 = defineNuxtModule({
     if (storageModule && !opts._holoStorageFinalizeRegistered) {
       opts._holoStorageFinalizeRegistered = true;
       nuxt.hook("modules:done", () => {
-        const finalNormalized = storageModule.normalizeModuleOptions(opts._holoStorageModuleOptions);
-        opts.runtimeConfig = opts.runtimeConfig || {};
-        opts.runtimeConfig.holoStorage = finalNormalized;
-        storageModule.applyNitroStorageConfig(opts, finalNormalized, s3Driver);
-        if (storageModule.hasPublicLocalDisk(finalNormalized)) {
-          addServerHandler({
-            route: `${finalNormalized.routePrefix}/**`,
-            handler: resolver.resolve("./runtime/server/routes/storage.get")
-          });
-        }
+        finalizeStorageSetup(storageModule, opts, resolver, s3Driver);
       });
     }
     if (!opts._holoTypesRegistered) {
@@ -625,11 +405,22 @@ const module$1 = defineNuxtModule({
 });
 const moduleInternals = {
   addViteOptimizeDeps,
+  addVitePlugin,
+  addNitroErrorHandler,
+  createRealtimeDefinitionVitePlugin,
+  existsFile,
+  hasProjectPackage,
   hasModuleNotFoundCode,
   hasLoadedConfigFile,
   importOptionalStorageS3Module,
+  applyStorageRuntimeConfig,
+  finalizeStorageSetup,
+  resolveStorageSetup,
   isModuleResolutionFailure,
-  resolveClientOptimizeDeps
+  isRealtimeDefinitionModule,
+  resolveClientOptimizeDeps,
+  resolveExistingRealtimeDefinitionFile,
+  resolveRealtimeDefinitionImport
 };
 const adapterNuxtInternals = {
   toStorageModuleOptions

package/dist/runtime/composables/forms.js

@@ -1,6 +1,6 @@
 import { onScopeDispose, reactive, shallowRef, watchEffect } from "vue";
 import { useCookie } from "#app";
-import { normalizeHoloHttpError } from "@holo-js/core/errors";
+import { normalizeHoloHttpError } from "@holo-js/adapter-shared";
 import { DEFAULT_VALIDATION_BAG, createErrorBag } from "@holo-js/validation";
 import {
   createFormClient
@@ -105,10 +105,10 @@ function createHttpHandledFormOptions(options) {
 }
 export function useValidationErrors(bag = DEFAULT_VALIDATION_BAG) {
   const payload = parseFlashedValidationPayload();
-  if (!payload || (payload.bag ?? DEFAULT_VALIDATION_BAG) !== bag) {
+  if (!payload || payload.bag !== bag) {
     return createErrorBag();
   }
-  return createErrorBag(payload.errors ?? {});
+  return createErrorBag(payload.errors);
 }
 function getValueAtPath(root, path) {
   const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
@@ -157,11 +157,9 @@ function createArrayMutationView(source, path, getForm, version, cache) {
         return false;
       }
       const next = current.slice();
-      const updated = Reflect.set(next, key, value);
-      if (updated) {
-        void getForm().setValue(path, next);
-      }
-      return updated;
+      Reflect.set(next, key, value);
+      void getForm().setValue(path, next);
+      return true;
     },
     deleteProperty(_target, key) {
       const current = getValueAtPath(getForm().values, path);
@@ -169,11 +167,9 @@ function createArrayMutationView(source, path, getForm, version, cache) {
         return false;
       }
       const next = current.slice();
-      const deleted = Reflect.deleteProperty(next, key);
-      if (deleted) {
-        void getForm().setValue(path, next);
-      }
-      return deleted;
+      Reflect.deleteProperty(next, key);
+      void getForm().setValue(path, next);
+      return true;
     }
   });
   cache.set(source, proxy);
@@ -240,12 +236,7 @@ export function useForm(schemaDefinition, options = {}) {
   const values = reactive(rawValues);
   const arrayCache = /* @__PURE__ */ new WeakMap();
   let activeForm;
-  const getActiveForm = () => {
-    if (!activeForm) {
-      throw new TypeError("Expected form to be initialized.");
-    }
-    return activeForm;
-  };
+  const getActiveForm = () => activeForm;
   const currentForm = () => {
     const current = form.value;
     if (!current) {
@@ -322,3 +313,16 @@ export function useForm(schemaDefinition, options = {}) {
     }
   });
 }
+export const nuxtFormInternals = {
+  isLeafValue,
+  readBrowserCookie,
+  readCookie,
+  parseFlashedValidationPayload,
+  getHttpFailureMessage,
+  renderFormHttpFailure,
+  createHttpHandledFormOptions,
+  getValueAtPath,
+  createArrayMutationView,
+  defineLeafAccessor,
+  syncValuesView
+};

package/dist/runtime/composables/realtime.js

@@ -1,5 +1,5 @@
 import { onScopeDispose, reactive } from "vue";
-import { normalizeHoloHttpError } from "@holo-js/core/errors";
+import { normalizeHoloHttpError } from "@holo-js/adapter-shared";
 import {
   configureRealtimeClientRuntime,
   configureRealtimeClientTransport,
@@ -57,6 +57,11 @@ function replaceRealtimeReactiveValue(target, value) {
   }
   return value;
 }
+function connectRealtimeStoreInBrowser(store) {
+  if ("window" in globalThis) {
+    store.connect();
+  }
+}
 function useReactiveRealtimeQuery(definition, args) {
   const store = getRealtimeQueryStore(definition, args);
   const initialData = store.snapshot?.data;
@@ -67,9 +72,7 @@ function useReactiveRealtimeQuery(definition, args) {
       current = replaceRealtimeReactiveValue(current, nextData);
     }
   });
-  if ("window" in globalThis) {
-    store.connect();
-  }
+  connectRealtimeStoreInBrowser(store);
   onScopeDispose(unsubscribe);
   return current;
 }
@@ -78,4 +81,12 @@ configureRealtimeClientRuntime({
   useQuery: useReactiveRealtimeQuery
 });
 configureRealtimeClientTransport(createBroadcastRealtimeTransport());
+export const nuxtRealtimeInternals = {
+  emitRealtimeError,
+  replaceReactiveObject,
+  replaceReactiveArray,
+  createRealtimeReactiveValue,
+  replaceRealtimeReactiveValue,
+  connectRealtimeStoreInBrowser
+};
 export {};

package/dist/runtime/server/error.js

@@ -13,7 +13,7 @@ function findValidationException(error) {
   }
   return findValidationException(error.cause);
 }
-export default defineNitroErrorHandler(async (error, event) => {
+export default async function handleValidationError(error, event) {
   const validationError = findValidationException(error);
   if (!validationError) {
     return;
@@ -29,4 +29,4 @@ export default defineNitroErrorHandler(async (error, event) => {
   setResponseStatus(event, payload.status);
   setHeader(event, "content-type", "application/json; charset=utf-8");
   await send(event, JSON.stringify(payload), "application/json");
-});
+}

package/dist/runtime/server/form-failure.js

@@ -98,3 +98,6 @@ export function applyFormFailureRedirect(event, response, failure) {
   setHeader(event, response, "content-type", "text/html; charset=utf-8");
   appendSetCookie(event, response, serializeFormFailureCookie(failure));
 }
+export const formFailureInternals = {
+  appendSetCookie
+};

package/dist/runtime/server/routes/storage.get.js

@@ -1,5 +1,6 @@
 import { open, realpath, stat } from "node:fs/promises";
 import { extname, resolve, sep } from "node:path";
+import { createError, defineEventHandler, getRequestURL, setResponseHeader } from "h3";
 import { useRuntimeConfig } from "#imports";
 const NAMED_PUBLIC_DISK_ROUTE_SEGMENT = "__holo";
 function normalizeRequestPath(value) {
@@ -40,14 +41,9 @@ function resolveContentType(absolutePath) {
       return "text/css; charset=utf-8";
     case ".gif":
       return "image/gif";
-    case ".html":
-      return "text/html; charset=utf-8";
     case ".jpeg":
     case ".jpg":
       return "image/jpeg";
-    case ".js":
-    case ".mjs":
-      return "text/javascript; charset=utf-8";
     case ".json":
       return "application/json; charset=utf-8";
     case ".mp3":
@@ -56,8 +52,6 @@ function resolveContentType(absolutePath) {
       return "application/pdf";
     case ".png":
       return "image/png";
-    case ".svg":
-      return "image/svg+xml";
     case ".txt":
       return "text/plain; charset=utf-8";
     case ".webp":

package/dist/runtime/shims.d.ts

@@ -75,15 +75,6 @@ declare global {
     ): Record<string, TModule>
   }
 
-  function createError(input: { statusCode: number, statusMessage: string }): Error
-  function defineNitroErrorHandler<T>(handler: T): T
-  function defineNitroPlugin<T>(plugin: T): T
-  function defineEventHandler<T>(
-    handler: (event: unknown) => T | Promise<T>,
-  ): (event: unknown) => T | Promise<T>
-  function getRequestURL(event: unknown): URL
-  function setResponseHeader(event: unknown, name: string, value: string): void
-  function useRuntimeConfig(): HoloRuntimeConfig
 }
 
 export {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/adapter-nuxt",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "Holo-JS Framework - Nuxt adapter",
   "type": "module",
   "license": "MIT",
@@ -38,19 +38,20 @@
     "test": "vitest --run"
   },
   "dependencies": {
+    "@holo-js/adapter-shared": "^0.3.0",
     "@nuxt/kit": "^4.4.4",
-    "@holo-js/config": "^0.2.6",
-    "@holo-js/core": "^0.2.6",
-    "@holo-js/db": "^0.2.6",
-    "@holo-js/validation": "^0.2.6",
+    "@holo-js/config": "^0.3.0",
+    "@holo-js/core": "^0.3.0",
+    "@holo-js/db": "^0.3.0",
+    "@holo-js/validation": "^0.3.0",
     "h3": "^1.15.11"
   },
   "peerDependencies": {
-    "@holo-js/broadcast": "^0.2.6",
-    "@holo-js/forms": "^0.2.6",
-    "@holo-js/realtime": "^0.2.6",
-    "@holo-js/storage": "^0.2.6",
-    "@holo-js/storage-s3": "^0.2.6"
+    "@holo-js/broadcast": "^0.3.0",
+    "@holo-js/forms": "^0.3.0",
+    "@holo-js/realtime": "^0.3.0",
+    "@holo-js/storage": "^0.3.0",
+    "@holo-js/storage-s3": "^0.3.0"
   },
   "peerDependenciesMeta": {
     "@holo-js/broadcast": {
@@ -70,9 +71,9 @@
     }
   },
   "devDependencies": {
-    "@holo-js/broadcast": "^0.2.6",
-    "@holo-js/realtime": "^0.2.6",
-    "@holo-js/storage-s3": "^0.2.6",
+    "@holo-js/broadcast": "^0.3.0",
+    "@holo-js/realtime": "^0.3.0",
+    "@holo-js/storage-s3": "^0.3.0",
     "@nuxt/module-builder": "^1.0.2",
     "@types/node": "^22.10.2",
     "nuxt": "^4.4.4",