@zenithbuild/runtime 0.6.6 → 0.6.9

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { signal } from "./signal.js";
+export { state } from "./state.js";
+export { zeneffect } from "./zeneffect.js";
+export { hydrate } from "./hydrate.js";
+export { zenWindow, zenDocument } from "./env.js";
+export { zenOn, zenResize, collectRefs } from "./platform.js";

package/dist/platform.d.ts

@@ -0,0 +1,11 @@
+type ResizeSize = {
+    w: number;
+    h: number;
+};
+export declare function zenOn(target: EventTarget | null, eventName: string, handler: EventListener, options?: AddEventListenerOptions | boolean): () => void;
+export declare function zenResize(handler: (size: ResizeSize) => void): () => void;
+type RefLike<T extends Element> = {
+    current?: T | null;
+} | null | undefined;
+export declare function collectRefs<T extends Element>(...refs: RefLike<T>[]): T[];
+export {};

package/dist/platform.js

@@ -1,70 +1,51 @@
 // ---------------------------------------------------------------------------
-// platform.js — Zenith Runtime canonical DOM/platform helpers
+// platform.ts — Zenith Runtime canonical DOM/platform helpers
 // ---------------------------------------------------------------------------
 // zenOn: SSR-safe event subscription with disposer
 // zenResize: window resize handler with rAF throttle
 // collectRefs: deterministic null-filtered ref collection
 // ---------------------------------------------------------------------------
-
 import { zenWindow } from './env.js';
-
-/**
- * SSR-safe event subscription. Returns disposer.
- * @param {EventTarget | null} target
- * @param {string} eventName
- * @param {EventListener} handler
- * @param {AddEventListenerOptions | boolean} [options]
- * @returns {() => void}
- */
 export function zenOn(target, eventName, handler, options) {
     if (!target || typeof target.addEventListener !== 'function') {
-        return () => {};
+        return () => { };
     }
     target.addEventListener(eventName, handler, options);
     return () => {
         target.removeEventListener(eventName, handler, options);
     };
 }
-
-/**
- * Window resize handler with requestAnimationFrame throttle.
- * Returns disposer.
- * @param {(size: { w: number; h: number }) => void} handler
- * @returns {() => void}
- */
 export function zenResize(handler) {
     const win = zenWindow();
     if (!win || typeof win.addEventListener !== 'function') {
-        return () => {};
+        return () => { };
     }
-    const hasRaf =
-        typeof win.requestAnimationFrame === 'function'
-        && typeof win.cancelAnimationFrame === 'function';
+    const activeWindow = win;
+    const hasRaf = typeof activeWindow.requestAnimationFrame === 'function'
+        && typeof activeWindow.cancelAnimationFrame === 'function';
     let scheduledId = null;
     let lastW = Number.NaN;
     let lastH = Number.NaN;
-
     const schedule = (callback) => {
         if (hasRaf) {
-            return win.requestAnimationFrame(callback);
+            return activeWindow.requestAnimationFrame(callback);
         }
-        return win.setTimeout(callback, 0);
+        return activeWindow.setTimeout(callback, 0);
     };
-
     const cancel = (id) => {
         if (hasRaf) {
-            win.cancelAnimationFrame(id);
+            activeWindow.cancelAnimationFrame(id);
             return;
         }
-        win.clearTimeout(id);
+        activeWindow.clearTimeout(id);
     };
-
     function onResize() {
-        if (scheduledId !== null) return;
+        if (scheduledId !== null)
+            return;
         scheduledId = schedule(() => {
             scheduledId = null;
-            const w = win.innerWidth;
-            const h = win.innerHeight;
+            const w = activeWindow.innerWidth;
+            const h = activeWindow.innerHeight;
             if (w !== lastW || h !== lastH) {
                 lastW = w;
                 lastH = h;
@@ -72,28 +53,20 @@ export function zenResize(handler) {
             }
         });
     }
-
-    win.addEventListener('resize', onResize);
+    activeWindow.addEventListener('resize', onResize);
     onResize();
-
     return () => {
         if (scheduledId !== null) {
             cancel(scheduledId);
             scheduledId = null;
         }
-        win.removeEventListener('resize', onResize);
+        activeWindow.removeEventListener('resize', onResize);
     };
 }
-
-/**
- * Deterministic null-filtered collection of ref.current values.
- * @param {...{ current?: Element | null }} refs
- * @returns {Element[]}
- */
 export function collectRefs(...refs) {
     const out = [];
-    for (let i = 0; i < refs.length; i++) {
-        const node = refs[i] && refs[i].current;
+    for (let index = 0; index < refs.length; index += 1) {
+        const node = refs[index]?.current;
         if (node && typeof node === 'object' && typeof node.nodeType === 'number') {
             out.push(node);
         }

package/dist/ref.d.ts

@@ -0,0 +1,4 @@
+export type ZenithRef<T> = {
+    current: T | null;
+};
+export declare function ref<T>(initialValue?: T): ZenithRef<T>;

package/dist/ref.js

@@ -1,5 +1,5 @@
 // ---------------------------------------------------------------------------
-// ref.js — Zenith Runtime ref primitive
+// ref.ts — Zenith Runtime ref primitive
 // ---------------------------------------------------------------------------
 // A structural DOM pointer. NOT reactive.
 // ref.current is a plain property — no tracking, no proxies, no subscriptions.
@@ -10,14 +10,6 @@
 //   - .current is assigned by runtime at mount, before zenMount callbacks run
 //   - .current is set to null on component disposal
 //   - Reading .current does NOT register a dependency in zenEffect
-
-/**
- * Create a deterministic ref for structural DOM binding.
- *
- * @template T
- * @param {T} [initialValue]
- * @returns {{ current: T | null }}
- */
 export function ref(initialValue) {
     return { current: initialValue ?? null };
 }

package/dist/runtime.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mount a page module that already contains deterministic binding tables.
+ *
+ * @param {HTMLElement} container
+ * @param {object | function} pageModule
+ * @returns {() => void}
+ */
+export function mount(container: HTMLElement, pageModule: object | Function): () => void;

package/dist/runtime.js

@@ -3,10 +3,8 @@
 // ---------------------------------------------------------------------------
 // Backward-compatible mount wrapper around explicit hydrate(payload).
 // ---------------------------------------------------------------------------
-
 import { hydrate } from './hydrate.js';
 import { cleanup } from './cleanup.js';
-
 /**
  * Mount a page module that already contains deterministic binding tables.
  *
@@ -18,19 +16,15 @@ export function mount(container, pageModule) {
     if (!container || typeof container.querySelectorAll !== 'function') {
         throw new Error('[Zenith Runtime] mount(container, pageModule) requires a DOM container');
     }
-
     const pageFactory = _resolvePageFactory(pageModule);
     if (!pageFactory) {
         throw new Error('[Zenith Runtime] mount(container, pageModule) requires default() or __zenith_page()');
     }
-
     const page = pageFactory();
     if (!page || typeof page.html !== 'string') {
         throw new Error('[Zenith Runtime] __zenith_page() must return an object with html');
     }
-
     container.innerHTML = page.html;
-
     hydrate({
         root: container,
         ir_version: page.ir_version,
@@ -41,17 +35,19 @@ export function mount(container, pageModule) {
         signals: Array.isArray(page.signals) ? page.signals : [],
         components: Array.isArray(page.components) ? page.components : []
     });
-
     return function unmount() {
         cleanup();
         container.innerHTML = '';
     };
 }
-
 function _resolvePageFactory(pageModule) {
-    if (typeof pageModule === 'function') return pageModule;
-    if (!pageModule || typeof pageModule !== 'object') return null;
-    if (typeof pageModule.default === 'function') return pageModule.default;
-    if (typeof pageModule.__zenith_page === 'function') return pageModule.__zenith_page;
+    if (typeof pageModule === 'function')
+        return pageModule;
+    if (!pageModule || typeof pageModule !== 'object')
+        return null;
+    if (typeof pageModule.default === 'function')
+        return pageModule.default;
+    if (typeof pageModule.__zenith_page === 'function')
+        return pageModule.__zenith_page;
     return null;
 }

package/dist/signal.d.ts

@@ -0,0 +1,7 @@
+export type ZenithSignal<T> = {
+    __zenith_id: number;
+    get(): T;
+    set(nextValue: T): T;
+    subscribe(fn: (value: T) => void): () => void;
+};
+export declare function signal<T>(initialValue: T): ZenithSignal<T>;

package/dist/signal.js

@@ -1,5 +1,5 @@
 // ---------------------------------------------------------------------------
-// signal.js — Zenith Runtime V0
+// signal.ts — Zenith Runtime V0
 // ---------------------------------------------------------------------------
 // Minimal explicit signal primitive.
 //
@@ -16,18 +16,10 @@
 //   - No async queue
 // ---------------------------------------------------------------------------
 import { _nextReactiveId, _trackDependency } from './zeneffect.js';
-
-/**
- * Create a deterministic signal with explicit subscription semantics.
- *
- * @param {*} initialValue
- * @returns {{ get: () => *, set: (next: *) => *, subscribe: (fn: (value: *) => void) => () => void }}
- */
 export function signal(initialValue) {
     let value = initialValue;
     const subscribers = new Set();
     const reactiveId = _nextReactiveId();
-
     return {
         __zenith_id: reactiveId,
         get() {
@@ -38,21 +30,17 @@ export function signal(initialValue) {
             if (Object.is(value, nextValue)) {
                 return value;
             }
-
             value = nextValue;
-
             const snapshot = [...subscribers];
-            for (let i = 0; i < snapshot.length; i++) {
-                snapshot[i](value);
+            for (let index = 0; index < snapshot.length; index += 1) {
+                snapshot[index](value);
             }
-
             return value;
         },
         subscribe(fn) {
             if (typeof fn !== 'function') {
                 throw new Error('[Zenith Runtime] signal.subscribe(fn) requires a function');
             }
-
             subscribers.add(fn);
             return function unsubscribe() {
                 subscribers.delete(fn);

package/dist/state.d.ts

@@ -0,0 +1,10 @@
+type PlainState = Record<string, unknown>;
+type StateUpdater<T extends PlainState> = T | ((prev: Readonly<T>) => T);
+export type ZenithState<T extends PlainState> = {
+    __zenith_id: number;
+    get(): Readonly<T>;
+    set(patch: StateUpdater<T>): Readonly<T>;
+    subscribe(fn: (next: Readonly<T>) => void): () => void;
+};
+export declare function state<T extends PlainState>(initialValue: T): ZenithState<T>;
+export {};

package/dist/state.js

@@ -1,5 +1,5 @@
 // ---------------------------------------------------------------------------
-// state.js — Zenith Runtime V0
+// state.ts — Zenith Runtime V0
 // ---------------------------------------------------------------------------
 // Proxy-free immutable state helper.
 //
@@ -10,14 +10,12 @@
 //   store.set((prev) => ({ ...prev, count: prev.count + 1 }));
 // ---------------------------------------------------------------------------
 import { _nextReactiveId, _trackDependency } from './zeneffect.js';
-
 function isPlainObject(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return false;
     }
     return Object.prototype.toString.call(value) === '[object Object]';
 }
-
 function cloneSnapshot(value) {
     if (Array.isArray(value)) {
         return [...value];
@@ -27,18 +25,10 @@ function cloneSnapshot(value) {
     }
     return value;
 }
-
-/**
- * Create a proxy-free immutable state container.
- *
- * @param {object} initialValue
- * @returns {{ get: () => object, set: (patch: object | ((prev: object) => object)) => object, subscribe: (fn: (next: object) => void) => () => void }}
- */
 export function state(initialValue) {
     let current = Object.freeze(cloneSnapshot(initialValue));
     const subscribers = new Set();
     const reactiveId = _nextReactiveId();
-
     return {
         __zenith_id: reactiveId,
         get() {
@@ -49,30 +39,24 @@ export function state(initialValue) {
             const nextValue = typeof nextPatch === 'function'
                 ? nextPatch(current)
                 : { ...current, ...nextPatch };
-
-            if (!nextValue || typeof nextValue !== 'object' || Array.isArray(nextValue)) {
+            if (!isPlainObject(nextValue)) {
                 throw new Error('[Zenith Runtime] state.set(next) must resolve to a plain object');
             }
-
             const nextSnapshot = Object.freeze(cloneSnapshot(nextValue));
             if (Object.is(current, nextSnapshot)) {
                 return current;
             }
-
             current = nextSnapshot;
-
             const snapshot = [...subscribers];
-            for (let i = 0; i < snapshot.length; i++) {
-                snapshot[i](current);
+            for (let index = 0; index < snapshot.length; index += 1) {
+                snapshot[index](current);
             }
-
             return current;
         },
         subscribe(fn) {
             if (typeof fn !== 'function') {
                 throw new Error('[Zenith Runtime] state.subscribe(fn) requires a function');
             }
-
             subscribers.add(fn);
             return function unsubscribe() {
                 subscribers.delete(fn);

package/dist/template.d.ts

@@ -0,0 +1,2 @@
+export function runtimeModuleSource(): string;
+export function runtimeDevClientSource(): string;

package/dist/template.js

@@ -1,23 +1,18 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-
 function normalizeNewlines(value) {
     return String(value).replace(/\r\n/g, '\n').replace(/\r/g, '\n');
 }
-
 function readRuntimeSourceFile(fileName) {
     const fullPath = join(__dirname, fileName);
     return normalizeNewlines(readFileSync(fullPath, 'utf8'));
 }
-
 function stripImports(source) {
     return source.replace(/^\s*import\s+[^;]+;\s*$/gm, '').trim();
 }
-
 function buildRuntimeModuleSource() {
     const segments = [
         stripImports(readRuntimeSourceFile('zeneffect.js')),
@@ -30,16 +25,12 @@ function buildRuntimeModuleSource() {
         stripImports(readRuntimeSourceFile('cleanup.js')),
         stripImports(readRuntimeSourceFile('hydrate.js'))
     ].filter(Boolean);
-
     return normalizeNewlines(segments.join('\n\n'));
 }
-
 const RUNTIME_MODULE_SOURCE = buildRuntimeModuleSource();
-
 export function runtimeModuleSource() {
     return RUNTIME_MODULE_SOURCE;
 }
-
 const RUNTIME_DEV_CLIENT_SOURCE = `(() => {
   if (typeof window === 'undefined' || typeof document === 'undefined') return;
   if (window.__zenithDevClientActive === true) return;
@@ -441,7 +432,6 @@ const RUNTIME_DEV_CLIENT_SOURCE = `(() => {
     appendLog('[error] lost dev server connection');
   });
 })();`;
-
 export function runtimeDevClientSource() {
     return RUNTIME_DEV_CLIENT_SOURCE;
 }

package/dist/zeneffect.d.ts

@@ -0,0 +1,17 @@
+export declare function _nextReactiveId(): number;
+export declare function _trackDependency(source: any): void;
+export declare function resetGlobalSideEffects(): void;
+export declare function createSideEffectScope(label?: string): {
+    __zenith_scope: boolean;
+    id: number;
+    label: any;
+    mountReady: boolean;
+    disposed: boolean;
+    pendingMounts: never[];
+    disposers: never[];
+};
+export declare function activateSideEffectScope(scope: any): void;
+export declare function disposeSideEffectScope(scope: any): void;
+export declare function zenEffect(effect: any, options?: null, scopeOverride?: null): () => void;
+export declare function zeneffect(effectOrDependencies: any, optionsOrEffect: any, scopeOverride?: null): () => void;
+export declare function zenMount(callback: any, scopeOverride?: null): () => void;