@vmz/core 0.2.4 → 0.2.6

package/dist/ssr/document.d.ts

@@ -0,0 +1,2 @@
+export declare let _ssrDocumentLastError: any;
+export declare function ensureSsrDocument(): boolean;

package/dist/ssr/document.js

@@ -0,0 +1,71 @@
+export let _ssrDocumentLastError = null;
+export function ensureSsrDocument() {
+    if (typeof globalThis.document !== 'undefined' && typeof globalThis.document.createElement === 'function') {
+        return true;
+    }
+    const proc = globalThis.process;
+    if (!proc?.versions?.node) {
+        _ssrDocumentLastError = new Error('vmz:dom SSR document: not running on Node');
+        return false;
+    }
+    try {
+        // Node 20.16+ / 22.3+: sync builtin load without a static `node:` import.
+        const mod = typeof proc.getBuiltinModule === 'function' ? proc.getBuiltinModule('module') : null;
+        if (!mod?.createRequire) {
+            _ssrDocumentLastError = new Error('vmz:dom SSR document: createRequire unavailable');
+            return false;
+        }
+        const pathMod = typeof proc.getBuiltinModule === 'function' ? proc.getBuiltinModule('path') : null;
+        const createRequire = mod.createRequire;
+        const bases = [];
+        bases.push(import.meta.url);
+        if (pathMod && typeof proc.cwd === 'function') {
+            bases.push(pathMod.join(proc.cwd(), 'package.json'));
+        }
+        const errors = [];
+        let parseHTML = null;
+        for (const base of bases) {
+            let req;
+            try {
+                req = createRequire(base);
+            }
+            catch (e) {
+                errors.push(`${base}: createRequire failed: ${e && e.message ? e.message : e}`);
+                continue;
+            }
+            try {
+                parseHTML = req('linkedom').parseHTML;
+                break;
+            }
+            catch (e) {
+                errors.push(`${base} ??linkedom: ${e && e.message ? e.message : e}`);
+            }
+            // Walk into @vmz/core's dependency tree (linkedom is declared there).
+            for (const coreId of ['@vmz/core', '@vmz/core/dom', '@vmz/core/server']) {
+                try {
+                    const coreEntry = req.resolve(coreId);
+                    parseHTML = createRequire(coreEntry)('linkedom').parseHTML;
+                    break;
+                }
+                catch (e) {
+                    errors.push(`${base} ??${coreId}/linkedom: ${e && e.message ? e.message : e}`);
+                }
+            }
+            if (parseHTML)
+                break;
+        }
+        if (typeof parseHTML !== 'function') {
+            const detail = errors.length ? `\n${errors.join('\n')}` : '';
+            throw new Error(`linkedom unresolved for SSR document${detail}`);
+        }
+        const { window, document } = parseHTML('<!DOCTYPE html><html><body></body></html>');
+        globalThis.window = window;
+        globalThis.document = document;
+        _ssrDocumentLastError = null;
+        return typeof document.createElement === 'function';
+    }
+    catch (err) {
+        _ssrDocumentLastError = err instanceof Error ? err : new Error(String(err));
+        return false;
+    }
+}

package/dist/ssr/dom-ssr.d.ts

@@ -1,47 +1,10 @@
-/**
- * VMZ DOM SSR / hydrate / resume ??precise patches, no VDOM diff.
- * Imports client DOM primitives from ./dom-core.js for tree-shakeable browser entry.
- */
-import { findOwnedDefaultSlot } from '../browser/dom-core.js';
-export declare function renderToString(Component: any, props?: any, opts?: any): Promise<any>;
-/**
- * Stream SSR via the same Direct serialize schedule as `renderToString`.
- * Yields HTML chunks (open tag ??children ??close). Joining chunks equals `renderToString`.
- * Supports AbortSignal for cancel; consumers should respect backpressure (await between chunks).
- */
-export declare function renderToStream(Component: any, props?: any, opts?: any): AsyncGenerator<any, void, unknown>;
-/**
- * Live-DOM counterpart: first default `<slot>` owned by this tree, not by a nested
- * `[data-vmz]` component (Button/Link labels, etc.).
- * Re-exported from dom-core (single implementation).
- */
-export { findOwnedDefaultSlot };
-/**
- * Hydrate/mount a file-route page inside an optional layout chain (outer ??inner).
- * Mirrors SSR `slotHtml` wrapping: each layout's owned default slot becomes the
- * outlet for the next layout or the page. Retains layout instances on `container`
- * so SPA transitions can dispose only the page host.
- */
-export declare function hydrateRoute(Page: any, container: any, props?: {}, layoutCtors?: any[], opts?: {}): Promise<any>;
-/**
- * SPA same-layout transition: dispose only the page host, keep layout instances.
- * Callers must verify `data-vmz-layout` is unchanged before using this.
- */
-export declare function hydrateRoutePage(Page: any, container: any, props?: any, opts?: any): Promise<any>;
-/**
- * resume: attach to existing Island DOM without re-running construct structure or onMount.
- * Consumes ResumeEntry product (`data-vmz-resume`) derived from the same Execution Plan.
- */
-export declare function resume(Component: any, container: any, slice?: any): Promise<any>;
-/**
- * Resume all `[data-vmz-island]` hosts (prefer ResumeEntry / EventEntry over mount).
- * Event strategy islands wait for the DOM event before attach (lazy EventEntry).
- */
-export declare function resumeIslands(root?: Document): void;
-/**
- * EventEntry attach: only wire `client:event` / `client:event:*` islands.
- * Idle/load/visible ResumeEntries are left alone (static shell can defer framework work).
- */
-export declare function attachEventEntries(root?: Document): void;
-export declare function hydrate(Component: any, container: any, props?: any, opts?: any): Promise<any>;
-export declare function hydrateIslands(root?: Document): void;
+/** SSR and resume barrel. */
+export { renderToString } from './render.js';
+export { renderToStream } from './render.js';
+export { hydrateRoute } from '../browser/resume/hydrate.js';
+export { hydrateRoutePage } from '../browser/resume/hydrate.js';
+export { hydrate } from '../browser/resume/hydrate.js';
+export { hydrateIslands } from '../browser/resume/hydrate.js';
+export { resume } from '../browser/resume/resume.js';
+export { resumeIslands } from '../browser/resume/resume.js';
+export { attachEventEntries } from '../browser/resume/resume.js';