@zenithbuild/runtime 0.6.5 → 0.6.7

package/dist/zeneffect.js

@@ -1,5 +1,6 @@
+// @ts-nocheck
 // ---------------------------------------------------------------------------
-// zeneffect.js — Zenith Runtime V0
+// zeneffect.ts — Zenith Runtime V0
 // ---------------------------------------------------------------------------
 // Explicit dependency effect primitive.
 //
@@ -12,30 +13,25 @@
 //   - No scheduler
 //   - No async queue
 // ---------------------------------------------------------------------------
-
 const DEFAULT_EFFECT_OPTIONS = {
     debounceMs: 0,
     throttleMs: 0,
     raf: false,
     flush: 'post'
 };
-
 let _activeDependencyCollector = null;
 let _reactiveIdCounter = 0;
 let _scopeIdCounter = 0;
 let _effectIdCounter = 0;
-
 export function _nextReactiveId() {
     _reactiveIdCounter += 1;
     return _reactiveIdCounter;
 }
-
 export function _trackDependency(source) {
     if (typeof _activeDependencyCollector === 'function') {
         _activeDependencyCollector(source);
     }
 }
-
 function createInternalScope(label, mountReady) {
     _scopeIdCounter += 1;
     return {
@@ -48,61 +44,51 @@ function createInternalScope(label, mountReady) {
         disposers: []
     };
 }
-
 let _globalScope = createInternalScope('global', true);
-
 function isScope(value) {
     return !!value && typeof value === 'object' && value.__zenith_scope === true;
 }
-
 function resolveScope(scopeOverride) {
     if (isScope(scopeOverride)) {
         return scopeOverride;
     }
     return _globalScope;
 }
-
 export function resetGlobalSideEffects() {
     disposeSideEffectScope(_globalScope);
     _globalScope = createInternalScope('global', true);
 }
-
 export function createSideEffectScope(label = 'anonymous') {
     return createInternalScope(label, false);
 }
-
 export function activateSideEffectScope(scope) {
     if (!isScope(scope) || scope.disposed || scope.mountReady) {
         return;
     }
     scope.mountReady = true;
-
     const pending = scope.pendingMounts.slice();
     scope.pendingMounts.length = 0;
-
     for (let i = 0; i < pending.length; i++) {
         const callback = pending[i];
-        if (typeof callback !== 'function') continue;
+        if (typeof callback !== 'function')
+            continue;
         try {
             callback();
-        } catch {
+        }
+        catch {
             // failed effect mounts should not crash sibling nodes
         }
     }
 }
-
 function registerScopeDisposer(scope, disposer) {
     if (typeof disposer !== 'function') {
         return () => { };
     }
-
     if (!scope || scope.disposed) {
         disposer();
         return () => { };
     }
-
     scope.disposers.push(disposer);
-
     return function unregisterScopeDisposer() {
         if (!scope || scope.disposed) {
             return;
@@ -113,18 +99,14 @@ function registerScopeDisposer(scope, disposer) {
         }
     };
 }
-
 export function disposeSideEffectScope(scope) {
     if (!scope || scope.disposed) {
         return;
     }
-
     scope.disposed = true;
-
     const disposers = scope.disposers.slice();
     scope.disposers.length = 0;
     scope.pendingMounts.length = 0;
-
     for (let i = disposers.length - 1; i >= 0; i--) {
         const disposer = disposers[i];
         if (typeof disposer !== 'function') {
@@ -132,56 +114,45 @@ export function disposeSideEffectScope(scope) {
         }
         try {
             disposer();
-        } catch {
+        }
+        catch {
             // cleanup failures must never break teardown flow
         }
     }
 }
-
 function normalizeDelay(value, fieldName) {
     if (value === undefined || value === null) {
         return 0;
     }
     if (!Number.isFinite(value) || value < 0) {
-        throw new Error(
-            `[Zenith Runtime] zenEffect options.${fieldName} must be a non-negative number`
-        );
+        throw new Error(`[Zenith Runtime] zenEffect options.${fieldName} must be a non-negative number`);
     }
     return Math.floor(value);
 }
-
 function normalizeEffectOptions(options) {
     if (options === undefined || options === null) {
         return DEFAULT_EFFECT_OPTIONS;
     }
-
     if (!options || typeof options !== 'object' || Array.isArray(options)) {
         throw new Error('[Zenith Runtime] zenEffect(effect, options) requires options object when provided');
     }
-
     const normalized = {
         debounceMs: normalizeDelay(options.debounceMs, 'debounceMs'),
         throttleMs: normalizeDelay(options.throttleMs, 'throttleMs'),
         raf: options.raf === true,
         flush: options.flush === 'sync' ? 'sync' : 'post'
     };
-
     if (options.flush !== undefined && options.flush !== 'sync' && options.flush !== 'post') {
         throw new Error('[Zenith Runtime] zenEffect options.flush must be "post" or "sync"');
     }
-
-    const schedulingModes =
-        (normalized.debounceMs > 0 ? 1 : 0) +
+    const schedulingModes = (normalized.debounceMs > 0 ? 1 : 0) +
         (normalized.throttleMs > 0 ? 1 : 0) +
         (normalized.raf ? 1 : 0);
-
     if (schedulingModes > 1) {
         throw new Error('[Zenith Runtime] zenEffect options may use only one scheduler: debounceMs, throttleMs, or raf');
     }
-
     return normalized;
 }
-
 function drainCleanupStack(cleanups) {
     for (let i = cleanups.length - 1; i >= 0; i--) {
         const cleanup = cleanups[i];
@@ -190,36 +161,32 @@ function drainCleanupStack(cleanups) {
         }
         try {
             cleanup();
-        } catch {
+        }
+        catch {
             // swallow cleanup errors to preserve deterministic teardown
         }
     }
     cleanups.length = 0;
 }
-
 function applyCleanupResult(result, registerCleanup) {
     if (typeof result === 'function') {
         registerCleanup(result);
         return;
     }
-
     if (result && typeof result === 'object' && typeof result.cleanup === 'function') {
         registerCleanup(result.cleanup);
     }
 }
-
 function requireFunction(callback, label) {
     if (typeof callback !== 'function') {
         throw new Error(`[Zenith Runtime] ${label} requires callback function`);
     }
 }
-
 function createMountContext(registerCleanup) {
     return {
         cleanup: registerCleanup
     };
 }
-
 function createEffectContext(registerCleanup) {
     return {
         cleanup: registerCleanup,
@@ -244,7 +211,6 @@ function createEffectContext(registerCleanup) {
             requireFunction(callback, 'zenEffect context.debounce(callback, delayMs)');
             const waitMs = normalizeDelay(delayMs, 'debounce');
             let timeoutId = null;
-
             const wrapped = (...args) => {
                 if (timeoutId !== null) {
                     clearTimeout(timeoutId);
@@ -254,14 +220,12 @@ function createEffectContext(registerCleanup) {
                     callback(...args);
                 }, waitMs);
             };
-
             registerCleanup(() => {
                 if (timeoutId !== null) {
                     clearTimeout(timeoutId);
                     timeoutId = null;
                 }
             });
-
             return wrapped;
         },
         throttle(callback, delayMs) {
@@ -270,12 +234,10 @@ function createEffectContext(registerCleanup) {
             let timeoutId = null;
             let lastRun = 0;
             let pendingArgs = null;
-
             const invoke = (args) => {
                 lastRun = Date.now();
                 callback(...args);
             };
-
             const wrapped = (...args) => {
                 const now = Date.now();
                 const elapsed = now - lastRun;
@@ -288,12 +250,10 @@ function createEffectContext(registerCleanup) {
                     invoke(args);
                     return;
                 }
-
                 pendingArgs = args;
                 if (timeoutId !== null) {
                     return;
                 }
-
                 timeoutId = setTimeout(() => {
                     timeoutId = null;
                     if (pendingArgs) {
@@ -303,7 +263,6 @@ function createEffectContext(registerCleanup) {
                     }
                 }, waitMs - elapsed);
             };
-
             registerCleanup(() => {
                 if (timeoutId !== null) {
                     clearTimeout(timeoutId);
@@ -311,19 +270,16 @@ function createEffectContext(registerCleanup) {
                 }
                 pendingArgs = null;
             });
-
             return wrapped;
         }
     };
 }
-
 function createScheduler(runNow, options) {
     let microtaskQueued = false;
     let debounceTimer = null;
     let throttleTimer = null;
     let rafHandle = null;
     let lastRunAt = 0;
-
     function clearScheduledWork() {
         if (debounceTimer !== null) {
             clearTimeout(debounceTimer);
@@ -336,14 +292,14 @@ function createScheduler(runNow, options) {
         if (rafHandle !== null) {
             if (typeof cancelAnimationFrame === 'function') {
                 cancelAnimationFrame(rafHandle);
-            } else {
+            }
+            else {
                 clearTimeout(rafHandle);
             }
             rafHandle = null;
         }
         microtaskQueued = false;
     }
-
     function invokeNow() {
         microtaskQueued = false;
         debounceTimer = null;
@@ -352,7 +308,6 @@ function createScheduler(runNow, options) {
         lastRunAt = Date.now();
         runNow();
     }
-
     function schedule() {
         if (options.debounceMs > 0) {
             if (debounceTimer !== null) {
@@ -361,7 +316,6 @@ function createScheduler(runNow, options) {
             debounceTimer = setTimeout(invokeNow, options.debounceMs);
             return;
         }
-
         if (options.throttleMs > 0) {
             const now = Date.now();
             const elapsed = now - lastRunAt;
@@ -369,50 +323,44 @@ function createScheduler(runNow, options) {
                 invokeNow();
                 return;
             }
-
             if (throttleTimer !== null) {
                 return;
             }
-
             throttleTimer = setTimeout(invokeNow, options.throttleMs - elapsed);
             return;
         }
-
         if (options.raf) {
             if (rafHandle !== null) {
                 if (typeof cancelAnimationFrame === 'function') {
                     cancelAnimationFrame(rafHandle);
-                } else {
+                }
+                else {
                     clearTimeout(rafHandle);
                 }
             }
-
             if (typeof requestAnimationFrame === 'function') {
                 rafHandle = requestAnimationFrame(invokeNow);
-            } else {
+            }
+            else {
                 rafHandle = setTimeout(invokeNow, 16);
             }
             return;
         }
-
         if (options.flush === 'sync') {
             invokeNow();
             return;
         }
-
         if (microtaskQueued) {
             return;
         }
         microtaskQueued = true;
         queueMicrotask(invokeNow);
     }
-
     return {
         schedule,
         cancel: clearScheduledWork
     };
 }
-
 function queueWhenScopeReady(scope, callback) {
     if (!scope || scope.disposed) {
         return;
@@ -423,32 +371,25 @@ function queueWhenScopeReady(scope, callback) {
     }
     scope.pendingMounts.push(callback);
 }
-
 function createAutoTrackedEffect(effect, options, scope) {
     let disposed = false;
     const activeSubscriptions = new Map();
     const runCleanups = [];
-
     _effectIdCounter += 1;
     const effectId = _effectIdCounter;
-
     function registerCleanup(cleanup) {
         if (typeof cleanup !== 'function') {
             throw new Error('[Zenith Runtime] cleanup(fn) requires a function');
         }
         runCleanups.push(cleanup);
     }
-
     function runEffectNow() {
         if (disposed || !scope || scope.disposed) {
             return;
         }
-
         drainCleanupStack(runCleanups);
-
         const nextDependenciesById = new Map();
         const previousCollector = _activeDependencyCollector;
-
         _activeDependencyCollector = (source) => {
             if (!source || typeof source.subscribe !== 'function') {
                 return;
@@ -458,22 +399,19 @@ function createAutoTrackedEffect(effect, options, scope) {
                 nextDependenciesById.set(reactiveId, source);
             }
         };
-
         try {
             const result = effect(createEffectContext(registerCleanup));
             applyCleanupResult(result, registerCleanup);
-        } finally {
+        }
+        finally {
             _activeDependencyCollector = previousCollector;
         }
-
         const nextDependencies = Array.from(nextDependenciesById.values()).sort((left, right) => {
             const leftId = Number.isInteger(left.__zenith_id) ? left.__zenith_id : 0;
             const rightId = Number.isInteger(right.__zenith_id) ? right.__zenith_id : 0;
             return leftId - rightId;
         });
-
         const nextSet = new Set(nextDependencies);
-
         for (const [dependency, unsubscribe] of activeSubscriptions.entries()) {
             if (nextSet.has(dependency)) {
                 continue;
@@ -483,95 +421,70 @@ function createAutoTrackedEffect(effect, options, scope) {
             }
             activeSubscriptions.delete(dependency);
         }
-
         for (let i = 0; i < nextDependencies.length; i++) {
             const dependency = nextDependencies[i];
             if (activeSubscriptions.has(dependency)) {
                 continue;
             }
-
             const unsubscribe = dependency.subscribe(() => {
                 scheduler.schedule();
             });
-
-            activeSubscriptions.set(
-                dependency,
-                typeof unsubscribe === 'function' ? unsubscribe : () => { }
-            );
+            activeSubscriptions.set(dependency, typeof unsubscribe === 'function' ? unsubscribe : () => { });
         }
-
         void effectId;
     }
-
     const scheduler = createScheduler(runEffectNow, options);
-
     function disposeEffect() {
         if (disposed) {
             return;
         }
         disposed = true;
-
         scheduler.cancel();
-
         for (const unsubscribe of activeSubscriptions.values()) {
             if (typeof unsubscribe === 'function') {
                 unsubscribe();
             }
         }
         activeSubscriptions.clear();
-
         drainCleanupStack(runCleanups);
     }
-
     registerScopeDisposer(scope, disposeEffect);
     queueWhenScopeReady(scope, () => scheduler.schedule());
-
     return disposeEffect;
 }
-
 function createExplicitDependencyEffect(effect, dependencies, scope) {
     if (!Array.isArray(dependencies)) {
         throw new Error('[Zenith Runtime] zeneffect(deps, fn) requires an array of dependencies');
     }
-
     if (dependencies.length === 0) {
         throw new Error('[Zenith Runtime] zeneffect(deps, fn) requires at least one dependency');
     }
-
     if (typeof effect !== 'function') {
         throw new Error('[Zenith Runtime] zeneffect(deps, fn) requires a function');
     }
-
     const unsubscribers = dependencies.map((dep, index) => {
         if (!dep || typeof dep.subscribe !== 'function') {
             throw new Error(`[Zenith Runtime] zeneffect dependency at index ${index} must expose subscribe(fn)`);
         }
-
         return dep.subscribe(() => {
             effect();
         });
     });
-
     effect();
-
     return function dispose() {
         for (let i = 0; i < unsubscribers.length; i++) {
             unsubscribers[i]();
         }
     };
 }
-
 export function zenEffect(effect, options = null, scopeOverride = null) {
     if (typeof effect !== 'function') {
         throw new Error('[Zenith Runtime] zenEffect(effect) requires a callback function');
     }
-
     const opts = normalizeEffectOptions(options);
     const scope = resolveScope(scopeOverride);
-
     return createAutoTrackedEffect(effect, opts, scope);
 }
-
 export function zeneffect(effectOrDependencies, optionsOrEffect, scopeOverride = null) {
     if (Array.isArray(effectOrDependencies)) {
         if (typeof optionsOrEffect !== 'function') {
@@ -579,61 +492,48 @@ export function zeneffect(effectOrDependencies, optionsOrEffect, scopeOverride =
         }
         return createExplicitDependencyEffect(optionsOrEffect, effectOrDependencies, resolveScope(scopeOverride));
     }
-
     if (typeof effectOrDependencies === 'function') {
-        return createAutoTrackedEffect(
-            effectOrDependencies,
-            normalizeEffectOptions(optionsOrEffect),
-            resolveScope(scopeOverride)
-        );
+        return createAutoTrackedEffect(effectOrDependencies, normalizeEffectOptions(optionsOrEffect), resolveScope(scopeOverride));
     }
-
     throw new Error('[Zenith Runtime] zeneffect() invalid arguments. Expected (effect) or (dependencies, effect)');
 }
-
 export function zenMount(callback, scopeOverride = null) {
     if (typeof callback !== 'function') {
         throw new Error('[Zenith Runtime] zenMount(callback) requires a function');
     }
-
     const scope = resolveScope(scopeOverride);
     const cleanups = [];
     let executed = false;
     let registeredDisposer = null;
-
     function registerCleanup(fn) {
         if (typeof fn !== 'function') {
             throw new Error('[Zenith Runtime] cleanup(fn) requires a function');
         }
         cleanups.push(fn);
     }
-
     function runMount() {
         if (scope.disposed || executed) {
             return;
         }
-
         executed = true;
-
         try {
             const result = callback(createMountContext(registerCleanup));
             applyCleanupResult(result, registerCleanup);
-        } catch (error) {
+        }
+        catch (error) {
             // Unhandled mount errors shouldn't crash hydration, but we log them
             console.error('[Zenith Runtime] Unhandled error during zenMount:', error);
         }
-
         registeredDisposer = registerScopeDisposer(scope, () => {
             drainCleanupStack(cleanups);
         });
     }
-
     queueWhenScopeReady(scope, runMount);
-
     return function dispose() {
         if (registeredDisposer) {
             registeredDisposer();
-        } else {
+        }
+        else {
             drainCleanupStack(cleanups);
         }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/runtime",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -19,15 +19,27 @@
     "LICENSE",
     "package.json"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zenithbuild/framework",
+    "directory": "packages/runtime"
+  },
+  "bugs": {
+    "url": "https://github.com/zenithbuild/framework/issues"
+  },
+  "homepage": "https://github.com/zenithbuild/framework#readme",
   "scripts": {
-    "build": "mkdir -p dist && cp -a src/* dist/",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && NODE_OPTIONS=--experimental-vm-modules jest --config jest.config.js",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
+    "@types/node": "latest",
     "@jest/globals": "^30.2.0",
     "jest": "^30.2.0",
-    "jest-environment-jsdom": "^30.2.0"
+    "jest-environment-jsdom": "^30.2.0",
+    "typescript": "^5.7.3"
   },
   "private": false
 }