@zenithbuild/runtime 0.7.5 → 0.7.7

package/dist/payload.js

@@ -1,49 +1,20 @@
 export function _validatePayload(payload) {
-    if (!payload || typeof payload !== 'object') {
-        throw new Error('[Zenith Runtime] hydrate(payload) requires an object payload');
-    }
+    _ar(payload, 'hydrate(payload) requires an object payload');
     if (payload.ir_version !== 1) {
-        throw new Error('[Zenith Runtime] unsupported ir_version (expected 1)');
+        _pe('unsupported ir_version (expected 1)');
     }
     const root = payload.root;
-    const hasQuery = !!root && typeof root.querySelectorAll === 'function';
-    if (!hasQuery) {
-        throw new Error('[Zenith Runtime] hydrate(payload) requires payload.root with querySelectorAll');
-    }
-    const expressions = payload.expressions;
-    if (!Array.isArray(expressions)) {
-        throw new Error('[Zenith Runtime] hydrate(payload) requires expressions[]');
-    }
-    const markers = payload.markers;
-    if (!Array.isArray(markers)) {
-        throw new Error('[Zenith Runtime] hydrate(payload) requires markers[]');
-    }
-    const events = payload.events;
-    if (!Array.isArray(events)) {
-        throw new Error('[Zenith Runtime] hydrate(payload) requires events[]');
-    }
+    if (!root || typeof root.querySelectorAll !== 'function') {
+        _pe('hydrate(payload) requires payload.root with querySelectorAll');
+    }
+    const expressions = _aa(payload.expressions, 'hydrate(payload) requires expressions[]');
+    const markers = _aa(payload.markers, 'hydrate(payload) requires markers[]');
+    const events = _aa(payload.events, 'hydrate(payload) requires events[]');
+    const stateValues = _aa(payload.state_values, 'hydrate(payload) requires state_values[]');
+    const signals = _aa(payload.signals, 'hydrate(payload) requires signals[]');
     const refs = Array.isArray(payload.refs) ? payload.refs : [];
-    const stateValues = payload.state_values;
-    if (!Array.isArray(stateValues)) {
-        throw new Error('[Zenith Runtime] hydrate(payload) requires state_values[]');
-    }
     const stateKeys = Array.isArray(payload.state_keys) ? payload.state_keys : [];
-    if (!Array.isArray(stateKeys)) {
-        throw new Error('[Zenith Runtime] hydrate(payload) requires state_keys[] when provided');
-    }
-    for (let i = 0; i < stateKeys.length; i++) {
-        if (typeof stateKeys[i] !== 'string') {
-            throw new Error(`[Zenith Runtime] state_keys[${i}] must be a string`);
-        }
-    }
-    const signals = payload.signals;
-    if (!Array.isArray(signals)) {
-        throw new Error('[Zenith Runtime] hydrate(payload) requires signals[]');
-    }
     const components = Array.isArray(payload.components) ? payload.components : [];
-    const route = typeof payload.route === 'string' && payload.route.length > 0
-        ? payload.route
-        : '<unknown>';
     const params = payload.params && typeof payload.params === 'object'
         ? payload.params
         : {};
@@ -51,200 +22,108 @@ export function _validatePayload(payload) {
         ? payload.ssr_data
         : {};
     const exprFns = Array.isArray(payload.expr_fns) ? payload.expr_fns : [];
+    for (let i = 0; i < stateKeys.length; i++) {
+        if (typeof stateKeys[i] !== 'string') {
+            _pe(`state_keys[${i}] must be a string`);
+        }
+    }
     if (markers.length !== expressions.length) {
-        throw new Error(`[Zenith Runtime] marker/expression mismatch: markers=${markers.length}, expressions=${expressions.length}`);
+        _pe(`marker/expression mismatch: markers=${markers.length}, expressions=${expressions.length}`);
     }
     for (let i = 0; i < expressions.length; i++) {
         const expression = expressions[i];
-        if (!expression || typeof expression !== 'object' || Array.isArray(expression)) {
-            throw new Error(`[Zenith Runtime] expression at position ${i} must be an object`);
-        }
-        if (!Number.isInteger(expression.marker_index) || expression.marker_index < 0 || expression.marker_index >= expressions.length) {
-            throw new Error(`[Zenith Runtime] expression at position ${i} has invalid marker_index`);
-        }
+        _ar(expression, `expression at position ${i} must be an object`);
+        _air(expression.marker_index, expressions.length, `expression at position ${i} has invalid marker_index`);
         if (expression.marker_index !== i) {
-            throw new Error(`[Zenith Runtime] expression table out of order at position ${i}: marker_index=${expression.marker_index}`);
+            _pe(`expression table out of order at position ${i}: marker_index=${expression.marker_index}`);
         }
-        if (expression.fn_index !== undefined && expression.fn_index !== null) {
-            if (!Number.isInteger(expression.fn_index) || expression.fn_index < 0) {
-                throw new Error(`[Zenith Runtime] expression at position ${i} has invalid fn_index`);
-            }
+        if (expression.fn_index != null) {
+            _ani(expression.fn_index, `expression at position ${i} has invalid fn_index`);
         }
         _assertValidSourceSpan(expression.source, `expression[${i}]`);
         if (expression.signal_indices !== undefined) {
             if (!Array.isArray(expression.signal_indices)) {
-                throw new Error(`[Zenith Runtime] expression at position ${i} must provide signal_indices[]`);
+                _pe(`expression at position ${i} must provide signal_indices[]`);
             }
             for (let j = 0; j < expression.signal_indices.length; j++) {
-                if (!Number.isInteger(expression.signal_indices[j]) || expression.signal_indices[j] < 0) {
-                    throw new Error(`[Zenith Runtime] expression at position ${i} has invalid signal_indices[${j}]`);
-                }
+                _ani(expression.signal_indices[j], `expression at position ${i} has invalid signal_indices[${j}]`);
             }
         }
     }
     for (let i = 0; i < markers.length; i++) {
         const marker = markers[i];
-        if (!marker || typeof marker !== 'object' || Array.isArray(marker)) {
-            throw new Error(`[Zenith Runtime] marker at position ${i} must be an object`);
-        }
-        if (!Number.isInteger(marker.index) || marker.index < 0 || marker.index >= expressions.length) {
-            throw new Error(`[Zenith Runtime] marker at position ${i} has out-of-bounds index`);
-        }
+        _ar(marker, `marker at position ${i} must be an object`);
+        _air(marker.index, expressions.length, `marker at position ${i} has out-of-bounds index`);
         if (marker.index !== i) {
-            throw new Error(`[Zenith Runtime] marker table out of order at position ${i}: index=${marker.index}`);
+            _pe(`marker table out of order at position ${i}: index=${marker.index}`);
         }
         if (marker.kind !== 'text' && marker.kind !== 'attr' && marker.kind !== 'event') {
-            throw new Error(`[Zenith Runtime] marker at position ${i} has invalid kind`);
+            _pe(`marker at position ${i} has invalid kind`);
         }
-        if (typeof marker.selector !== 'string' || marker.selector.length === 0) {
-            throw new Error(`[Zenith Runtime] marker at position ${i} requires selector`);
-        }
-        if (marker.kind === 'attr' && (typeof marker.attr !== 'string' || marker.attr.length === 0)) {
-            throw new Error(`[Zenith Runtime] attr marker at position ${i} requires attr name`);
+        _as(marker.selector, `marker at position ${i} requires selector`);
+        if (marker.kind === 'attr') {
+            _as(marker.attr, `attr marker at position ${i} requires attr name`);
         }
         _assertValidSourceSpan(marker.source, `marker[${i}]`);
     }
     for (let i = 0; i < events.length; i++) {
         const eventBinding = events[i];
-        if (!eventBinding || typeof eventBinding !== 'object' || Array.isArray(eventBinding)) {
-            throw new Error(`[Zenith Runtime] event binding at position ${i} must be an object`);
-        }
-        if (!Number.isInteger(eventBinding.index) || eventBinding.index < 0 || eventBinding.index >= expressions.length) {
-            throw new Error(`[Zenith Runtime] event binding at position ${i} has out-of-bounds index`);
-        }
-        if (typeof eventBinding.event !== 'string' || eventBinding.event.length === 0) {
-            throw new Error(`[Zenith Runtime] event binding at position ${i} requires event name`);
-        }
-        if (typeof eventBinding.selector !== 'string' || eventBinding.selector.length === 0) {
-            throw new Error(`[Zenith Runtime] event binding at position ${i} requires selector`);
-        }
+        _ar(eventBinding, `event binding at position ${i} must be an object`);
+        _air(eventBinding.index, expressions.length, `event binding at position ${i} has out-of-bounds index`);
+        _as(eventBinding.event, `event binding at position ${i} requires event name`);
+        _as(eventBinding.selector, `event binding at position ${i} requires selector`);
         _assertValidSourceSpan(eventBinding.source, `event[${i}]`);
     }
     for (let i = 0; i < refs.length; i++) {
         const refBinding = refs[i];
-        if (!refBinding || typeof refBinding !== 'object' || Array.isArray(refBinding)) {
-            throw new Error(`[Zenith Runtime] ref binding at position ${i} must be an object`);
-        }
-        if (!Number.isInteger(refBinding.index) || refBinding.index < 0) {
-            throw new Error(`[Zenith Runtime] ref binding at position ${i} requires non-negative index`);
-        }
-        if (!Number.isInteger(refBinding.state_index) ||
-            refBinding.state_index < 0 ||
-            refBinding.state_index >= stateValues.length) {
-            throw new Error(`[Zenith Runtime] ref binding at position ${i} has out-of-bounds state_index`);
-        }
-        if (typeof refBinding.selector !== 'string' || refBinding.selector.length === 0) {
-            throw new Error(`[Zenith Runtime] ref binding at position ${i} requires selector`);
-        }
+        _ar(refBinding, `ref binding at position ${i} must be an object`);
+        _ani(refBinding.index, `ref binding at position ${i} requires non-negative index`);
+        _air(refBinding.state_index, stateValues.length, `ref binding at position ${i} has out-of-bounds state_index`);
+        _as(refBinding.selector, `ref binding at position ${i} requires selector`);
         _assertValidSourceSpan(refBinding.source, `ref[${i}]`);
         const candidate = stateValues[refBinding.state_index];
         if (!candidate || typeof candidate !== 'object' || !Object.prototype.hasOwnProperty.call(candidate, 'current')) {
-            throw new Error(`[Zenith Runtime] ref binding at position ${i} must resolve to a ref-like object`);
+            _pe(`ref binding at position ${i} must resolve to a ref-like object`);
         }
     }
     for (let i = 0; i < signals.length; i++) {
         const signalDescriptor = signals[i];
-        if (!signalDescriptor || typeof signalDescriptor !== 'object' || Array.isArray(signalDescriptor)) {
-            throw new Error(`[Zenith Runtime] signal descriptor at position ${i} must be an object`);
-        }
+        _ar(signalDescriptor, `signal descriptor at position ${i} must be an object`);
         if (signalDescriptor.kind !== 'signal') {
-            throw new Error(`[Zenith Runtime] signal descriptor at position ${i} requires kind="signal"`);
-        }
-        if (!Number.isInteger(signalDescriptor.id) || signalDescriptor.id < 0) {
-            throw new Error(`[Zenith Runtime] signal descriptor at position ${i} requires non-negative id`);
+            _pe(`signal descriptor at position ${i} requires kind="signal"`);
         }
+        _ani(signalDescriptor.id, `signal descriptor at position ${i} requires non-negative id`);
         if (signalDescriptor.id !== i) {
-            throw new Error(`[Zenith Runtime] signal table out of order at position ${i}: id=${signalDescriptor.id}`);
-        }
-        if (!Number.isInteger(signalDescriptor.state_index) || signalDescriptor.state_index < 0 || signalDescriptor.state_index >= stateValues.length) {
-            throw new Error(`[Zenith Runtime] signal descriptor at position ${i} has out-of-bounds state_index`);
+            _pe(`signal table out of order at position ${i}: id=${signalDescriptor.id}`);
         }
+        _air(signalDescriptor.state_index, stateValues.length, `signal descriptor at position ${i} has out-of-bounds state_index`);
     }
     for (let i = 0; i < components.length; i++) {
         const component = components[i];
-        if (!component || typeof component !== 'object' || Array.isArray(component)) {
-            throw new Error(`[Zenith Runtime] component at position ${i} must be an object`);
-        }
-        if (typeof component.instance !== 'string' || component.instance.length === 0) {
-            throw new Error(`[Zenith Runtime] component at position ${i} requires instance`);
-        }
-        if (typeof component.selector !== 'string' || component.selector.length === 0) {
-            throw new Error(`[Zenith Runtime] component at position ${i} requires selector`);
-        }
+        _ar(component, `component at position ${i} must be an object`);
+        _as(component.instance, `component at position ${i} requires instance`);
+        _as(component.selector, `component at position ${i} requires selector`);
         if (typeof component.create !== 'function') {
-            throw new Error(`[Zenith Runtime] component at position ${i} requires create() function`);
+            _pe(`component at position ${i} requires create() function`);
         }
         if (component.props !== undefined) {
             if (!Array.isArray(component.props)) {
-                throw new Error(`[Zenith Runtime] component at position ${i} requires props to be an array`);
+                _pe(`component at position ${i} requires props to be an array`);
             }
             for (let j = 0; j < component.props.length; j++) {
-                const prop = component.props[j];
-                if (!prop || typeof prop !== 'object' || Array.isArray(prop)) {
-                    throw new Error(`[Zenith Runtime] component prop at position ${j} for component ${i} must be an object`);
-                }
-                if (typeof prop.name !== 'string' || prop.name.length === 0) {
-                    throw new Error(`[Zenith Runtime] component prop at position ${j} for component ${i} requires a non-empty name`);
-                }
-                if (prop.type !== 'static' && prop.type !== 'signal') {
-                    throw new Error(`[Zenith Runtime] component prop "${prop.name}" for component ${i} has unsupported type "${prop.type}"`);
-                }
-                if (prop.type === 'static' && !Object.prototype.hasOwnProperty.call(prop, 'value')) {
-                    throw new Error(`[Zenith Runtime] component prop "${prop.name}" for component ${i} requires a value`);
-                }
-                if (prop.type === 'signal' && (!Number.isInteger(prop.index) || prop.index < 0)) {
-                    throw new Error(`[Zenith Runtime] component prop "${prop.name}" for component ${i} requires a valid signal index`);
-                }
+                _avp(component.props[j], j, i);
             }
         }
         _assertValidSourceSpan(component.source, `component[${i}]`);
     }
-    if (payload.params !== undefined) {
-        if (!payload.params || typeof payload.params !== 'object' || Array.isArray(payload.params)) {
-            throw new Error('[Zenith Runtime] hydrate() requires params object');
-        }
+    if (payload.params !== undefined && !_ir(payload.params)) {
+        _pe('hydrate() requires params object');
     }
-    if (payload.ssr_data !== undefined) {
-        if (!payload.ssr_data || typeof payload.ssr_data !== 'object' || Array.isArray(payload.ssr_data)) {
-            throw new Error('[Zenith Runtime] hydrate() requires ssr_data object');
-        }
+    if (payload.ssr_data !== undefined && !_ir(payload.ssr_data)) {
+        _pe('hydrate() requires ssr_data object');
     }
-    const props = payload.props && typeof payload.props === 'object' && !Array.isArray(payload.props)
-        ? payload.props
-        : {};
-    for (let i = 0; i < expressions.length; i++)
-        Object.freeze(expressions[i]);
-    for (let i = 0; i < markers.length; i++)
-        Object.freeze(markers[i]);
-    for (let i = 0; i < events.length; i++)
-        Object.freeze(events[i]);
-    for (let i = 0; i < refs.length; i++)
-        Object.freeze(refs[i]);
-    for (let i = 0; i < signals.length; i++)
-        Object.freeze(signals[i]);
-    for (let i = 0; i < components.length; i++) {
-        const c = components[i];
-        if (Array.isArray(c.props)) {
-            for (let j = 0; j < c.props.length; j++) {
-                const propDesc = c.props[j];
-                if (propDesc &&
-                    typeof propDesc === 'object' &&
-                    _isHydrationFreezableContainer(propDesc.value)) {
-                    Object.freeze(propDesc.value);
-                }
-                Object.freeze(propDesc);
-            }
-            Object.freeze(c.props);
-        }
-        Object.freeze(c);
-    }
-    Object.freeze(expressions);
-    Object.freeze(markers);
-    Object.freeze(events);
-    Object.freeze(refs);
-    Object.freeze(signals);
-    Object.freeze(components);
-    const validatedPayload = {
+    const props = _ir(payload.props) ? payload.props : {};
+    return {
         root,
         expressions,
         markers,
@@ -254,82 +133,112 @@ export function _validatePayload(payload) {
         stateKeys,
         signals,
         components,
-        route,
-        params: Object.freeze(params),
-        ssrData: Object.freeze(ssrData),
-        props: Object.freeze(props),
-        exprFns: Object.freeze(exprFns)
+        params: _f(params),
+        ssrData: _f(ssrData),
+        props: _f(props),
+        exprFns: _f(exprFns)
     };
-    return Object.freeze(validatedPayload);
 }
 function _assertValidSourceSpan(source, contextLabel) {
     if (source === undefined || source === null) {
         return;
     }
-    if (!source || typeof source !== 'object' || Array.isArray(source)) {
-        throw new Error(`[Zenith Runtime] ${contextLabel}.source must be an object`);
-    }
-    if (typeof source.file !== 'string' || source.file.length === 0) {
-        throw new Error(`[Zenith Runtime] ${contextLabel}.source.file must be a non-empty string`);
-    }
+    _ar(source, `${contextLabel}.source must be an object`);
+    _as(source.file, `${contextLabel}.source.file must be a non-empty string`);
     const points = ['start', 'end'];
     for (let i = 0; i < points.length; i++) {
         const point = source[points[i]];
         if (point === undefined || point === null) {
             continue;
         }
-        if (!point || typeof point !== 'object' || Array.isArray(point)) {
-            throw new Error(`[Zenith Runtime] ${contextLabel}.source.${points[i]} must be an object`);
-        }
-        if (!Number.isInteger(point.line) || point.line < 1) {
-            throw new Error(`[Zenith Runtime] ${contextLabel}.source.${points[i]}.line must be >= 1`);
-        }
-        if (!Number.isInteger(point.column) || point.column < 1) {
-            throw new Error(`[Zenith Runtime] ${contextLabel}.source.${points[i]}.column must be >= 1`);
-        }
+        _ar(point, `${contextLabel}.source.${points[i]} must be an object`);
+        _api(point.line, `${contextLabel}.source.${points[i]}.line must be >= 1`);
+        _api(point.column, `${contextLabel}.source.${points[i]}.column must be >= 1`);
     }
     if (source.snippet !== undefined && source.snippet !== null && typeof source.snippet !== 'string') {
-        throw new Error(`[Zenith Runtime] ${contextLabel}.source.snippet must be a string when provided`);
+        _pe(`${contextLabel}.source.snippet must be a string when provided`);
     }
 }
-export function _resolveComponentProps(propTable, signalMap, context = {}) {
+export function _resolveComponentProps(propTable, signalMap) {
     if (!Array.isArray(propTable)) {
-        throw new Error('[Zenith Runtime] component props must be an array');
+        _pe('component props must be an array');
     }
     const resolved = Object.create(null);
     for (let i = 0; i < propTable.length; i++) {
         const descriptor = propTable[i];
-        if (!descriptor || typeof descriptor !== 'object' || Array.isArray(descriptor)) {
-            throw new Error(`[Zenith Runtime] component prop descriptor at index ${i} must be an object`);
-        }
-        if (typeof descriptor.name !== 'string' || descriptor.name.length === 0) {
-            throw new Error(`[Zenith Runtime] component prop descriptor at index ${i} requires non-empty name`);
-        }
+        const name = descriptor.name;
         if (Object.prototype.hasOwnProperty.call(resolved, descriptor.name)) {
-            throw new Error(`[Zenith Runtime] duplicate component prop "${descriptor.name}"`);
+            _pe(`duplicate component prop "${name}"`);
         }
         if (descriptor.type === 'static') {
-            if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
-                throw new Error(`[Zenith Runtime] component prop "${descriptor.name}" static value is missing`);
-            }
-            resolved[descriptor.name] = descriptor.value;
+            resolved[name] = descriptor.value;
             continue;
         }
         if (descriptor.type === 'signal') {
-            if (!Number.isInteger(descriptor.index)) {
-                throw new Error(`[Zenith Runtime] component prop "${descriptor.name}" signal index must be an integer`);
-            }
             const signalValue = signalMap.get(descriptor.index);
             if (!signalValue || typeof signalValue.get !== 'function') {
-                throw new Error(`[Zenith Runtime]\nComponent: ${context.component || '<unknown>'}\nRoute: ${context.route || '<unknown>'}\nProp: ${descriptor.name}\nReason: signal index ${descriptor.index} did not resolve`);
+                _pe(`signal index ${descriptor.index} did not resolve`);
             }
-            resolved[descriptor.name] = signalValue;
+            resolved[name] = signalValue;
             continue;
         }
-        throw new Error(`[Zenith Runtime] unsupported component prop type "${descriptor.type}" for "${descriptor.name}"`);
+        _pe(`unsupported component prop type "${descriptor.type}" for "${name}"`);
     }
     return resolved;
 }
+function _pe(message) {
+    throw new Error(`[Zenith Runtime] ${message}`);
+}
+function _ir(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function _ar(value, message) {
+    if (!_ir(value)) {
+        _pe(message);
+    }
+}
+function _as(value, message) {
+    if (typeof value !== 'string' || value.length === 0) {
+        _pe(message);
+    }
+}
+function _ani(value, message) {
+    if (!Number.isInteger(value) || value < 0) {
+        _pe(message);
+    }
+}
+function _api(value, message) {
+    if (!Number.isInteger(value) || value < 1) {
+        _pe(message);
+    }
+}
+function _air(value, limit, message) {
+    if (!Number.isInteger(value) || value < 0 || value >= limit) {
+        _pe(message);
+    }
+}
+function _aa(value, message) {
+    if (!Array.isArray(value)) {
+        _pe(message);
+    }
+    return value;
+}
+function _f(value) {
+    return Object.freeze(value);
+}
+function _avp(prop, propIndex, componentIndex) {
+    _ar(prop, `component prop at position ${propIndex} for component ${componentIndex} must be an object`);
+    _as(prop.name, `component prop at position ${propIndex} for component ${componentIndex} requires a non-empty name`);
+    if (prop.type !== 'static' && prop.type !== 'signal') {
+        _pe(`component prop "${prop.name}" for component ${componentIndex} has unsupported type "${prop.type}"`);
+    }
+    if (prop.type === 'static' && !Object.prototype.hasOwnProperty.call(prop, 'value')) {
+        _pe(`component prop "${prop.name}" for component ${componentIndex} requires a value`);
+    }
+    if (prop.type === 'signal') {
+        _ani(prop.index, `component prop "${prop.name}" for component ${componentIndex} requires a valid signal index`);
+    }
+}
 export function _deepFreezePayload(obj) {
     if (!_isHydrationFreezableContainer(obj) || Object.isFrozen(obj))
         return;
@@ -337,7 +246,7 @@ export function _deepFreezePayload(obj) {
     const keys = Object.keys(obj);
     for (let i = 0; i < keys.length; i++) {
         const val = obj[keys[i]];
-        if (val && typeof val === 'object' && typeof val !== 'function') {
+        if (val && typeof val === 'object') {
             _deepFreezePayload(val);
         }
     }