zenith 0.0.1 → 1.0.0-beta.14

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Daniel Barber / Aleph1 Technologies Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# Zenith
+
+Zenith is a tiny reactive JavaScript framework with a virtual DOM, keyed reconciliation, and targeted component redraws. Its rendering model can update an entire application or a specific component, which is useful when parts of a page manage their own content, such as canvas, WebGL, and SVG interfaces.
+
+Zenith supports component lifecycle hooks, memoization, DOM events, SVG and MathML, and optional helpers. It is inspired by [Mithril.js](https://github.com/MithrilJS/mithril.js).
+
+**Status:** Zenith is currently in beta. We aim to keep the API stable through 1.0.0, but breaking changes may still occur during the beta period.
+
+## Installation
+
+Install the beta package:
+
+```sh
+npm install zenith@beta
+```
+
+Import the functions you need:
+
+```js
+import { bind, comp, compDef, elem } from 'zenith';
+```
+
+Prebuilt browser files are also included in `dist/`. The `zenith.global.js` build is intended for direct browser use; the `zenith.js` build is an ES module.
+
+## Example: counter
+
+```html
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <title>Zenith counter</title>
+  </head>
+  <body>
+    <main id="app"></main>
+    <script type="module">
+      import { bind, comp, compDef, elem } from 'zenith';
+
+      let count = 0;
+
+      const Counter = compDef({
+        draw: () => elem('button', {
+          onclick: () => { count++; }
+        }, `Count: ${count}`)
+      });
+
+      bind(document.querySelector('#app'), comp(Counter));
+    </script>
+  </body>
+</html>
+```
+
+The example assumes an environment that resolves npm package imports, such as a bundler or development server. Event handlers automatically schedule a redraw unless the event's `draw` property is set to `false`.
+
+## Components and redraws
+
+Create components with `compDef()` and `comp()`, then mount them using `bind()`. Call `draw()` when external state changes outside an event handler:
+
+```js
+import { bind, comp, compDef, draw, elem } from 'zenith';
+
+let message = 'Hello';
+
+const Message = compDef({
+  draw: () => elem('p', message)
+});
+
+const view = comp(Message);
+bind(document.querySelector('#app'), view);
+
+message = 'Updated';
+draw(view);
+```
+
+Redraws are scheduled in a microtask. Call `sync()` if you need to apply queued redraws immediately. `draw(view, true)` requests a targeted redraw of a component.
+
+Component definitions can use `init`, `draw`, `drawn`, `remove`, and `removed` lifecycle hooks. `remove` may return a Promise to defer removal. Components also support optional memoization through `$memo`.
+
+## Package builds
+
+The npm package includes prebuilt files under `dist/`, including:
+
+- `zenith.js` — ES module
+- `zenith.global.js` — global browser build
+- `zenith.development.js` — development build
+- `zenith-helpers.js` — optional helpers (import from `zenith/helpers`)
+
+The library is designed for a very small compressed footprint; actual size depends on the build and compression settings.
+
+## Documentation
+
+Additional information: [Zenith website](https://aleph-1.com/zenith) (work in progress).
+
+Report bugs and request features through [GitHub Issues](https://github.com/aleph1/Zenith/issues).
+
+## License
+
+[MIT](LICENSE)

package/dist/types/helpers/closest.d.ts

@@ -0,0 +1,14 @@
+import type { VNode } from '../vnode.defs';
+/**
+ * Finds the closest ancestor vNode matching the predicate.
+ * Walks up the tree from the given vNode's parent.
+ * Returns undefined if no match is found.
+ *
+ * @example
+ * // Find the closest list component ancestor
+ * const list = closest(vNode, n => n.is === is.comp && n.$def === List);
+ *
+ * // Find the closest ancestor with a specific attribute
+ * const themed = closest(vNode, n => n.attrs?.theme);
+ */
+export declare const closest: (vNode: VNode, predicate: (vNode: VNode) => boolean) => VNode | undefined;

package/dist/types/helpers/cls.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Combines class names, filtering out falsy values.
+ *
+ * @example
+ * cls('btn', isActive && 'btn-active', hasError && 'btn-error')
+ * // => 'btn btn-active' (if isActive, not hasError)
+ */
+export declare const cls: (...args: (string | false | null | undefined | 0)[]) => string;

package/dist/types/helpers/derived.d.ts

@@ -0,0 +1,19 @@
+import { Signal } from './signal';
+export interface DerivedSignal<T> extends Signal<T> {
+    destroy(): void;
+}
+/**
+ * Creates a computed signal that updates when any dependency changes.
+ * Call destroy() in component cleanup to prevent memory leaks.
+ *
+ * @example
+ * const firstName = signal('John');
+ * const lastName = signal('Smith');
+ * const fullName = derived(
+ *   () => `${firstName.val} ${lastName.val}`,
+ *   [firstName, lastName]
+ * );
+ * // In component cleanup:
+ * removed: () => fullName.destroy()
+ */
+export declare const derived: <T>(fn: () => T, deps: Signal<any>[]) => DerivedSignal<T>;

package/dist/types/helpers/html.d.ts

@@ -0,0 +1,20 @@
+import type { VNodeNode } from '../vnode.defs';
+/**
+ * Converts an HTML string to DOM nodes wrapped in node() vnodes.
+ *
+ * XSS WARNING: Only use with trusted, sanitized HTML.
+ * Never pass user-generated content without sanitization.
+ *
+ * @example
+ * // Safe static content
+ * html('<div class="card"><h2>Title</h2></div>')
+ *
+ * // Unsafe user input
+ * html(`<div>${userInput}</div>`)
+ *
+ * // Safe alternative
+ * elem('div', userInput)
+ *
+ * @see https://owasp.org/www-community/attacks/xss/
+ */
+export declare const html: (value: string | number | bigint) => VNodeNode | VNodeNode[];

package/dist/types/helpers/index.d.ts

@@ -0,0 +1,13 @@
+export { keep } from './keep';
+export { is } from './is';
+export { cls } from './cls';
+export { slot } from './slot';
+export { html } from './html';
+export { closest } from './closest';
+export { inject } from './inject';
+export { signal } from './signal';
+export type { Signal } from './signal';
+export { derived } from './derived';
+export type { DerivedSignal } from './derived';
+export { router } from './router';
+export { Portal } from './portal';

package/dist/types/helpers/index.iife.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers/inject.d.ts

@@ -0,0 +1,11 @@
+import type { VNode } from '../vnode.defs';
+/**
+ * Retrieves values provided by ancestor components.
+ * Walks up the tree collecting requested keys, with closer
+ * ancestors taking priority (shadowing).
+ * Returns an object with only the keys that were found.
+ *
+ * @example
+ * const { theme, locale } = inject(vNode, 'theme', 'locale');
+ */
+export declare const inject: (vNode: VNode, ...keys: string[]) => Record<string, any>;

package/dist/types/helpers/is.d.ts

@@ -0,0 +1,14 @@
+/**
+ * vNode type constants for use with predicate checks.
+ *
+ * @example
+ * if (vNode.is === is.elem) // is a DOM element
+ * if (vNode.is === is.comp) // is a component
+ */
+export declare const is: {
+    elem: number;
+    text: number;
+    comp: number;
+    node: number;
+    compDef: number;
+};

package/dist/types/helpers/keep.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A memoization predicate that prevents all re-renders.
+ * Pass to a component's $memo property to make it fully static.
+ *
+ * @example
+ * const Static = compDef({
+ *   $memo: keep,
+ *   draw: () => elem('div', 'I never re-render')
+ * });
+ */
+export declare const keep: () => boolean;

package/dist/types/helpers/portal.d.ts

@@ -0,0 +1,21 @@
+import type { VNodeComp, VNodeCompDefinition, VNodeAnyOrArray } from '../vnode.defs';
+interface PortalAttrs {
+    to: string | Element;
+    children: VNodeAnyOrArray;
+}
+/**
+ * Renders children to a different DOM location.
+ * Useful for modals, tooltips, and overlays that need
+ * to escape their parent's stacking context or overflow.
+ *
+ * @example
+ * comp(Portal, {
+ *   to: '#modals',         // CSS selector
+ *   to: document.body,     // or Element reference
+ *   children: comp(Modal)
+ * })
+ */
+export declare const Portal: VNodeCompDefinition<PortalAttrs> & {
+    to: (vNode: VNodeComp<PortalAttrs>) => Element | null;
+};
+export {};

package/dist/types/helpers/router.d.ts

@@ -0,0 +1,28 @@
+import type { VNodeCompDefinition, VNodeAnyOrArray } from '../vnode.defs';
+interface RouterOptions {
+    mode?: 'hash' | 'history';
+}
+type RouteComponent = (params: Record<string, string>) => VNodeAnyOrArray;
+interface RouterRoutes {
+    [pattern: string]: RouteComponent;
+    '*'?: RouteComponent;
+}
+/**
+ * Creates a hash or history-based router as a component definition.
+ * Supports dynamic params (:id) and wildcard routes (*).
+ *
+ * @example
+ * const App = router({
+ *   '/': () => comp(Home),
+ *   '/users/:id': ({ id }) => comp(User, { id }),
+ *   '*': () => comp(NotFound)
+ * });
+ *
+ * // Hash mode (default)
+ * draw(comp(App), document.body);
+ *
+ * // History mode
+ * draw(comp(router(routes, { mode: 'history' })), document.body);
+ */
+export declare const router: (routes: RouterRoutes, options?: RouterOptions) => VNodeCompDefinition;
+export {};

package/dist/types/helpers/signal.d.ts

@@ -0,0 +1,21 @@
+type SignalSubscriber<T> = (val: T) => void;
+export interface Signal<T> {
+    get val(): T;
+    set val(newVal: T);
+    sub(fn: SignalSubscriber<T>): () => void;
+    notify(): void;
+}
+/**
+ * Creates a reactive value that notifies subscribers on change.
+ * Uses strict inequality (!==) to detect changes, so object
+ * mutations won't trigger notifications — use immutable updates
+ * or call notify() manually.
+ *
+ * @example
+ * const count = signal(0);
+ * const unsub = count.sub(val => console.log(val));
+ * count.val = 1; // logs 1
+ * unsub();       // stop listening
+ */
+export declare const signal: <T>(val: T) => Signal<T>;
+export {};

package/dist/types/helpers/slot.d.ts

@@ -0,0 +1,29 @@
+import type { VNode, VNodeAttrs } from '../vnode.defs';
+/**
+ * Resolves a content slot to a renderable vNode.
+ * Supports multiple content formats for flexible component APIs.
+ *
+ * - string → returned as-is
+ * - function → called with attrs, returns result
+ * - array → each item recursively resolved
+ * - vNode → returned as-is
+ * - null / undefined → returns nothing
+ *
+ * Note: component definitions must be wrapped in comp() by the caller.
+ *
+ * @example
+ * const Card = compDef({
+ *   draw: (vNode) => elem('div', { class: 'card' },
+ *     slot(vNode.attrs.header, vNode.attrs),
+ *     slot(vNode.attrs.children, vNode.attrs)
+ *   )
+ * });
+ *
+ * // Usage
+ * comp(Card, {
+ *   header: elem('h2', 'Title'),              // vNode
+ *   children: (attrs) => elem('p', 'Hi'),     // function
+ *   children: comp(Modal, { ... }),           // wrap in comp() explicitly
+ * })
+ */
+export declare const slot: (content: VNode | VNode[] | string | ((attrs: VNodeAttrs) => VNode | VNode[] | string) | null | undefined, attrs: VNodeAttrs) => VNode | VNode[] | string | undefined;

package/dist/types/index.d.ts

@@ -0,0 +1,28 @@
+declare global {
+    interface Window {
+        DEBUG?: boolean;
+    }
+}
+import { VNodeElem, VNodeComp, VNodeNode, VNodeAny, VNodeArray, VNodeElemAttributes, VNodeCompAttributes, VNodeCompDefinition, VNodeContainer } from './vnode.defs';
+declare const ns: {
+    math: string;
+    svg: string;
+};
+export declare const diff: {
+    none: number;
+    self: number;
+    nodes: number;
+    all: number;
+};
+export declare const sync: () => void;
+export declare const draw: (vNode: VNodeContainer, surgical?: boolean) => void;
+export declare const elem: {
+    (tag: string): VNodeElem;
+    (tag: string, attrs: VNodeElemAttributes, ...args: VNodeArray): VNodeElem;
+    (tag: string, ...args: VNodeArray): VNodeElem;
+};
+export declare const compDef: (componentDefinition: VNodeCompDefinition) => VNodeCompDefinition;
+export declare const comp: (componentDefinition: VNodeCompDefinition, attrs?: VNodeCompAttributes) => VNodeComp;
+export declare const node: (el: Element) => VNodeNode;
+export declare const bind: (el: Element, vNodeAnyOrArray: VNodeAny | VNodeArray) => VNodeComp;
+export { ns };

package/dist/types/index.iife.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/vnode.defs.d.ts

@@ -0,0 +1,82 @@
+export declare const VNODE_ELEM = 1;
+export declare const VNODE_TEXT = 2;
+export declare const VNODE_COMP = 3;
+export declare const VNODE_NODE = 4;
+export declare const VNODE_COMPDEF = 5;
+export interface VNodeElemAttributes {
+    class?: string | string[];
+    style?: string | Record<string, string | number | null | undefined>;
+    $key?: string | number;
+    $diff?: number;
+    $remove?: boolean;
+    is?: string;
+    xmlns?: string;
+    [property: string]: any;
+}
+export interface VNodeCompAttributes {
+    $key?: string | number;
+    $remove?: boolean;
+    to?: string | Element;
+    [property: string]: any;
+}
+export type VNodeAttrs = VNodeElemAttributes | VNodeCompAttributes;
+export interface VNodeNodeAttributes {
+    [property: string]: any;
+}
+export interface VNodeCompDefinition<A extends VNodeCompAttributes = VNodeCompAttributes> {
+    $tag?: number;
+    init?: (vNode: VNodeComp<A>) => void;
+    draw: (vNode: VNodeComp<A>, oldChildren?: VNodeFlatArray) => VNodeAnyOrArray;
+    drawn?: (vNode: VNodeComp<A>, isFirstDraw?: boolean) => void;
+    remove?: (vNode: VNodeComp<A>) => Promise<void> | void;
+    removed?: (vNode: VNodeComp<A>) => void;
+    $memo?: boolean | ((newAttrs: A, oldAttrs: A) => boolean);
+}
+interface VNodeBase {
+    $h?: boolean;
+    up: VNodeContainer | null;
+    nodes: VNodeFlatArray | null;
+    el: any;
+}
+export interface VNodeElem extends VNodeBase {
+    is: typeof VNODE_ELEM;
+    $tag: string;
+    $def: null;
+    attrs: VNodeElemAttributes;
+    nodes: VNodeFlatArray;
+}
+export interface VNodeText extends VNodeBase {
+    is: typeof VNODE_TEXT;
+    $tag: string;
+    $def: null;
+    attrs: null;
+    nodes: null;
+}
+export interface VNodeComp<A extends VNodeCompAttributes = VNodeCompAttributes> extends VNodeBase {
+    is: typeof VNODE_COMP;
+    $tag: number;
+    $def: VNodeCompDefinition;
+    attrs: A;
+    nodes: VNodeFlatArray;
+    provide?: Record<string, any>;
+}
+export interface VNodeNode extends VNodeBase {
+    is: typeof VNODE_NODE;
+    $tag: string;
+    $def: null;
+    attrs: null;
+    nodes: null;
+}
+export type VNode = VNodeElem | VNodeText | VNodeComp | VNodeNode;
+export type VNodeAny = VNode;
+export type VNodeContainer = VNodeComp | VNodeElem;
+export type VNodeDrawable = VNodeComp;
+export type VNodeHTML = VNodeElem;
+export type VNodeDom = Node | Node[];
+export type VNodeChild = VNodeAny | string | number | boolean | null | undefined;
+export type VNodeArray = Array<VNodeChild | VNodeArray>;
+export type VNodeAnyOrArray = VNodeChild | VNodeArray;
+export interface VNodeFlatArray extends Array<VNodeAny> {
+    $keys?: Map<any, any> | null;
+}
+export {};

package/dist/zenith-helpers.development.js

@@ -0,0 +1,157 @@
+/*! Zenith Helpers v1.0.0-beta.14 | MIT License | © 2022-2025 Daniel Barber */
+import { node, draw } from './zenith.js';
+
+const keep = () => true;
+
+const VNODE_ELEM = 1;
+const VNODE_TEXT = 2;
+const VNODE_COMP = 3;
+const VNODE_NODE = 4;
+const VNODE_COMPDEF = 5;
+
+const is = {
+  elem: VNODE_ELEM,
+  text: VNODE_TEXT,
+  comp: VNODE_COMP,
+  node: VNODE_NODE,
+  compDef: VNODE_COMPDEF
+};
+
+const cls = (...args) => args.filter(Boolean).join(" ");
+
+const slot = (content, attrs) => {
+  if (content) {
+    if (typeof content === "function") return content(attrs);
+    return content;
+  }
+};
+
+const html = (value) => {
+  const container = document.createElement("div");
+  container.innerHTML = value + "";
+  const nodes = [...container.childNodes].map((child) => node(child));
+  return nodes.length === 1 ? nodes[0] : nodes;
+};
+
+const closest = (vNode, predicate) => {
+  for (let current = vNode.up; current; current = current.up) {
+    if (predicate(current)) return current;
+  }
+};
+
+const inject = (vNode, ...keys) => {
+  const result = {};
+  const needed = new Set(keys);
+  for (let current = vNode.up; current && needed.size > 0; current = current.up) {
+    if (current.is === VNODE_COMP && current.provide) {
+      for (const key of needed) {
+        if (current.provide[key] !== void 0) {
+          result[key] = current.provide[key];
+          needed.delete(key);
+        }
+      }
+    }
+  }
+  return result;
+};
+
+const signal = (val) => {
+  let _val = val;
+  const _fns = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const fn of _fns) fn(_val);
+  };
+  return {
+    get val() {
+      return _val;
+    },
+    set val(newVal) {
+      if (_val !== newVal) {
+        _val = newVal;
+        notify();
+      }
+    },
+    sub(fn) {
+      _fns.add(fn);
+      return () => _fns.delete(fn);
+    },
+    notify
+  };
+};
+
+const derived = (fn, deps) => {
+  const computed = signal(fn());
+  const cleanups = deps.map((dep) => dep.sub(() => {
+    computed.val = fn();
+  }));
+  computed.destroy = () => {
+    for (const cleanup of cleanups) cleanup();
+    cleanups.length = 0;
+  };
+  return computed;
+};
+
+const router = (routes, options = {}) => {
+  const isHistory = options.mode === "history";
+  const eventType = isHistory ? "popstate" : "hashchange";
+  const getPath = () => isHistory ? location.pathname : location.hash.slice(1) || "/";
+  const compiled = [];
+  const matchRoute = (path) => {
+    for (const route of compiled) {
+      const match = path.match(route.regex);
+      if (match) {
+        const params = {};
+        for (let i = 0; i < route.keys.length; i++) {
+          params[route.keys[i]] = match[i + 1];
+        }
+        return { component: route.component, params };
+      }
+    }
+    return { component: routes["*"] || null, params: {} };
+  };
+  for (const pattern in routes) {
+    const keys = [];
+    const regexPattern = pattern.replace(/:[^/]+/g, (match) => {
+      keys.push(match.slice(1));
+      return "([^/]+)";
+    }).replace(/\*/g, "(.*)");
+    compiled.push({
+      regex: new RegExp(`^${regexPattern}$`),
+      keys,
+      component: routes[pattern]
+    });
+  }
+  return {
+    init: (vNode) => {
+      const node = vNode;
+      const matched = matchRoute(getPath());
+      node.route = matched.component;
+      node.params = matched.params;
+      node.onroute = () => {
+        const matched2 = matchRoute(getPath());
+        node.route = matched2.component;
+        node.params = matched2.params;
+        draw(node, true);
+      };
+      window.addEventListener(eventType, node.onroute);
+    },
+    draw: (vNode) => {
+      var _a;
+      const node = vNode;
+      return (_a = node.route) == null ? void 0 : _a.call(node, node.params);
+    },
+    removed: (vNode) => {
+      const node = vNode;
+      if (node.onroute) {
+        window.removeEventListener(eventType, node.onroute);
+      }
+    }
+  };
+};
+
+const Portal = {
+  to: (vNode) => typeof vNode.attrs.to === "string" ? document.querySelector(vNode.attrs.to) : vNode.attrs.to,
+  draw: (vNode) => vNode.attrs.children
+};
+
+export { Portal, closest, cls, derived, html, inject, is, keep, router, signal, slot };

package/dist/zenith-helpers.global.js

@@ -0,0 +1,2 @@
+/*! Zenith Helpers v1.0.0-beta.14 | MIT License | © 2022-2025 Daniel Barber */
+!function(e){"use strict";const signal=e=>{let t=e;const o=new Set,n=()=>{for(const e of o)e(t)};return{get val(){return t},set val(e){t!==e&&(t=e,n())},sub:e=>(o.add(e),()=>o.delete(e)),notify:n}},t={keep:()=>!0,is:{elem:1,text:2,comp:3,node:4,compDef:5},cls:(...e)=>e.filter(Boolean).join(" "),slot:(e,t)=>{if(e)return"function"==typeof e?e(t):e},html:t=>{const o=document.createElement("div");o.innerHTML=t+"";const n=[...o.childNodes].map(t=>e.node(t));return 1===n.length?n[0]:n},closest:(e,t)=>{for(let o=e.up;o;o=o.up)if(t(o))return o},inject:(e,...t)=>{const o={},n=new Set(t);for(let t=e.up;t&&n.size>0;t=t.up)if(3===t.is&&t.provide)for(const e of n)void 0!==t.provide[e]&&(o[e]=t.provide[e],n.delete(e));return o},signal:signal,derived:(e,t)=>{const o=signal(e()),n=t.map(t=>t.sub(()=>{o.val=e()}));return o.destroy=()=>{for(const e of n)e();n.length=0},o},router:(t,o={})=>{const n="history"===o.mode,r=n?"popstate":"hashchange",s=()=>n?location.pathname:location.hash.slice(1)||"/",c=[],a=e=>{for(const t of c){const o=e.match(t.regex);if(o){const e={};for(let n=0;t.keys.length>n;n++)e[t.keys[n]]=o[n+1];return{component:t.component,params:e}}}return{component:t["*"]||null,params:{}}};for(const e in t){const o=[],n=e.replace(/:[^/]+/g,e=>(o.push(e.slice(1)),"([^/]+)")).replace(/\*/g,"(.*)");c.push({regex:RegExp(`^${n}$`),keys:o,component:t[e]})}return{init:t=>{const o=t,n=a(s());o.route=n.component,o.params=n.params,o.onroute=()=>{const t=a(s());o.route=t.component,o.params=t.params,e.draw(o,!0)},window.addEventListener(r,o.onroute)},draw:e=>{var t;return null==(t=e.route)?void 0:t.call(e,e.params)},removed:e=>{e.onroute&&window.removeEventListener(r,e.onroute)}}},Portal:{to:e=>"string"==typeof e.attrs.to?document.querySelector(e.attrs.to):e.attrs.to,draw:e=>e.attrs.children}};window.zh=t}(z);

package/dist/zenith-helpers.js

@@ -0,0 +1,2 @@
+/*! Zenith Helpers v1.0.0-beta.14 | MIT License | © 2022-2025 Daniel Barber */
+import{node as e,draw as t}from"./zenith.js";const keep=()=>!0,is={elem:1,text:2,comp:3,node:4,compDef:5},cls=(...e)=>e.filter(Boolean).join(" "),slot=(e,t)=>{if(e)return"function"==typeof e?e(t):e},html=t=>{const o=document.createElement("div");o.innerHTML=t+"";const n=[...o.childNodes].map(t=>e(t));return 1===n.length?n[0]:n},closest=(e,t)=>{for(let o=e.up;o;o=o.up)if(t(o))return o},inject=(e,...t)=>{const o={},n=new Set(t);for(let t=e.up;t&&n.size>0;t=t.up)if(3===t.is&&t.provide)for(const e of n)void 0!==t.provide[e]&&(o[e]=t.provide[e],n.delete(e));return o},signal=e=>{let t=e;const o=new Set,n=()=>{for(const e of o)e(t)};return{get val(){return t},set val(e){t!==e&&(t=e,n())},sub:e=>(o.add(e),()=>o.delete(e)),notify:n}},derived=(e,t)=>{const o=signal(e()),n=t.map(t=>t.sub(()=>{o.val=e()}));return o.destroy=()=>{for(const e of n)e();n.length=0},o},router=(e,o={})=>{const n="history"===o.mode,r=n?"popstate":"hashchange",s=()=>n?location.pathname:location.hash.slice(1)||"/",a=[],c=t=>{for(const e of a){const o=t.match(e.regex);if(o){const t={};for(let n=0;e.keys.length>n;n++)t[e.keys[n]]=o[n+1];return{component:e.component,params:t}}}return{component:e["*"]||null,params:{}}};for(const t in e){const o=[],n=t.replace(/:[^/]+/g,e=>(o.push(e.slice(1)),"([^/]+)")).replace(/\*/g,"(.*)");a.push({regex:RegExp(`^${n}$`),keys:o,component:e[t]})}return{init:e=>{const o=e,n=c(s());o.route=n.component,o.params=n.params,o.onroute=()=>{const e=c(s());o.route=e.component,o.params=e.params,t(o,!0)},window.addEventListener(r,o.onroute)},draw:e=>{var t;return null==(t=e.route)?void 0:t.call(e,e.params)},removed:e=>{e.onroute&&window.removeEventListener(r,e.onroute)}}},Portal={to:e=>"string"==typeof e.attrs.to?document.querySelector(e.attrs.to):e.attrs.to,draw:e=>e.attrs.children};export{Portal,closest,cls,derived,html,inject,is,keep,router,signal,slot};

package/dist/zenith.development.js

@@ -0,0 +1,537 @@
+/*! Zenith v1.0.0-beta.14 | MIT License | © 2022-2025 Daniel Barber */
+const VNODE_ELEM = 1;
+const VNODE_TEXT = 2;
+const VNODE_COMP = 3;
+const VNODE_NODE = 4;
+const VNODE_COMPDEF = 5;
+
+const boundNodes = /* @__PURE__ */ new Map();
+const redrawQueue = /* @__PURE__ */ new Set();
+const ns = {
+  math: "http://www.w3.org/1998/Math/MathML",
+  svg: "http://www.w3.org/2000/svg"
+};
+const FLAG_IS_DEFINED = 1;
+const FLAG_IS_STALE = 2;
+const FLAG_IS_REMOVING = 4;
+const FLAG_HAS_LIFECYCLE = 8;
+const FLAG_HAS_REMOVE = 16;
+const FLAG_HAS_REMOVED = 32;
+const FLAG_REMOVE_CALLED = 64;
+const DIFF_NONE = 1;
+const DIFF_SELF = 2;
+const DIFF_NODES = 4;
+const DIFF_ALL = DIFF_SELF | DIFF_NODES;
+const diff = {
+  none: DIFF_NONE,
+  self: DIFF_SELF,
+  nodes: DIFF_NODES,
+  all: DIFF_ALL
+};
+const ALWAYS_EMPTY_ARRAY = Object.freeze([]) ;
+const ALWAYS_EMPTY_OBJECT = Object.freeze({}) ;
+const ALWAYS_EMPTY_MAP = /* @__PURE__ */ new Map();
+const sync = () => {
+  let remaining = redrawQueue.size;
+  let targetEl;
+  if (remaining) {
+    const active = document.activeElement;
+    for (const redrawNode of redrawQueue) {
+      targetEl = boundNodes.has(redrawNode.el) ? redrawNode.el : redrawNode.attrs && redrawNode.attrs.to || redrawNode.el && redrawNode.el.parentNode || redrawNode.up && redrawNode.up.el;
+      redrawQueue.delete(redrawNode);
+      if (targetEl) {
+        _redrawComponent(redrawNode, targetEl);
+      }
+      if (!--remaining) break;
+    }
+    if (redrawQueue.size) Promise.resolve().then(sync);
+    if (active && active !== document.activeElement && typeof active.focus === "function") {
+      active.focus();
+    }
+  }
+};
+const draw = (vNode, surgical) => {
+  if (surgical) {
+    if (vNode.is === VNODE_COMP) {
+      vNode.$tag |= FLAG_IS_STALE;
+    }
+    redrawQueue.add(vNode);
+  } else {
+    let current;
+    for (current = vNode; current.up; current = current.up) ;
+    redrawQueue.add(current);
+    for (current = vNode; current.up; current = current.up) {
+      if (current.is === VNODE_COMP) {
+        if (current.$tag & FLAG_IS_STALE) break;
+        current.$tag |= FLAG_IS_STALE;
+      }
+    }
+  }
+  if (redrawQueue.size === 1) {
+    Promise.resolve().then(sync);
+  }
+};
+const _flattenReusableArray = [];
+const _flatten = (nodes, offset = 0, arr = []) => {
+  let node2;
+  if (!(nodes && typeof nodes === "object" && nodes.length != null)) {
+    _flattenReusableArray[0] = nodes;
+    nodes = _flattenReusableArray;
+  }
+  for (offset; offset < nodes.length; offset++) {
+    node2 = nodes[offset];
+    if (Array.isArray(node2)) {
+      _flatten(node2, 0, arr);
+    } else if (node2 != null) {
+      if (node2.is) {
+        if (arr.$keys === void 0) {
+          arr.$keys = node2.attrs && "$key" in node2.attrs ? ALWAYS_EMPTY_MAP : null;
+        } else if (!arr.$keys !== !(node2.attrs && "$key" in node2.attrs)) {
+          throw new Error("Children have mixed keys..." );
+        }
+        arr.push(node2);
+      } else if (node2 !== true && node2 !== false) {
+        if (arr.$keys === void 0) {
+          arr.$keys = null;
+        } else if (arr.$keys) {
+          throw new Error(`Children have mixed keys. Wrap strings in elem('span', {$key}, "My keyed string.")` );
+        }
+        arr.push({
+          is: VNODE_TEXT,
+          $tag: node2 + "",
+          $def: null,
+          attrs: null,
+          nodes: null,
+          up: null,
+          el: null
+        });
+      }
+    }
+  }
+  return arr;
+};
+const _lastRoot = (vNode) => {
+  if (vNode.is === VNODE_COMP && !vNode.attrs.to) {
+    for (let i = vNode.nodes.length - 1; i >= 0; i--) {
+      const root = _lastRoot(vNode.nodes[i]);
+      if (root) return root;
+    }
+    return null;
+  }
+  return vNode.el;
+};
+const _place = (vNode, parentEl, next) => {
+  if (vNode.is === VNODE_COMP && !vNode.attrs.to) {
+    for (let i = vNode.nodes.length - 1; i >= 0; i--) {
+      next = _place(vNode.nodes[i], parentEl, next);
+    }
+  } else if (vNode.el) {
+    if (vNode.el.nextSibling !== next) parentEl.insertBefore(vNode.el, next);
+    next = vNode.el;
+  }
+  return next;
+};
+const _updateNode = (parentNode, parentEl, newNode, oldNode, xmlns, skipMemo) => {
+  if (oldNode.el) {
+    const newNodeType = newNode.is;
+    if (newNodeType === oldNode.is) {
+      if (newNodeType === VNODE_ELEM) {
+        newNode.up = parentNode;
+        if (newNode.$tag === oldNode.$tag) {
+          newNode.el = oldNode.el;
+          newNode.$h = oldNode.$h;
+          const diff2 = newNode.attrs.$diff || DIFF_ALL;
+          if (diff2 & DIFF_SELF) {
+            _setElAttributes(newNode, oldNode.attrs);
+          }
+          if (diff2 & DIFF_NODES) {
+            _updateNodes(newNode, newNode.el, newNode.nodes, oldNode.nodes, newNode.attrs.xmlns || ns[newNode.$tag] || xmlns);
+          } else {
+            newNode.nodes = oldNode.nodes;
+          }
+        } else {
+          _create(parentNode, parentEl, newNode, xmlns);
+          parentEl.insertBefore(newNode.el, oldNode.el);
+          _remove(oldNode);
+        }
+      } else if (newNodeType === VNODE_TEXT) {
+        newNode.el = oldNode.el;
+        if (newNode.$tag !== oldNode.$tag) newNode.el.textContent = newNode.$tag;
+      } else if (newNodeType === VNODE_COMP) {
+        if (oldNode.$tag & FLAG_IS_REMOVING) {
+          oldNode.$tag &= ~FLAG_IS_REMOVING;
+        }
+        newNode.up = parentNode;
+        if (newNode.$def === oldNode.$def) {
+          newNode.el = oldNode.el;
+          newNode.$h = oldNode.$h;
+          newNode.nodes = oldNode.nodes;
+          if (skipMemo || oldNode.$tag & FLAG_IS_STALE || !newNode.$def.$memo || (newNode.$def.$memo === true ? newNode.attrs !== oldNode.attrs : !newNode.$def.$memo(newNode.attrs, oldNode.attrs))) {
+            newNode.$tag &= ~FLAG_IS_STALE;
+            _redrawComponent(newNode, parentEl, xmlns);
+          }
+        } else {
+          _create(parentNode, parentEl, newNode, xmlns);
+          _remove(oldNode);
+        }
+      } else if (newNodeType === VNODE_NODE) {
+        if (newNode.el !== oldNode.el) {
+          parentEl.insertBefore(newNode.el, null);
+          oldNode.el.remove();
+        }
+      }
+    } else {
+      _create(parentNode, parentEl, newNode, xmlns);
+      _remove(oldNode);
+    }
+  } else {
+    _create(parentNode, parentEl, newNode, xmlns);
+  }
+};
+const _updateNodes = (parentNode, parentEl, newNodes, oldNodes, xmlns, depth = 0) => {
+  const newNodesLength = newNodes.length;
+  const oldNodesLength = oldNodes.length;
+  if (newNodesLength) {
+    let oldNode;
+    let newNode;
+    let i = 0;
+    if (oldNodesLength) {
+      if (newNodes.$keys && oldNodes.$keys) {
+        while (i < newNodesLength && i < oldNodesLength && newNodes[i].attrs.$key === oldNodes[i].attrs.$key) {
+          _updateNode(parentNode, parentEl, newNodes[i], oldNodes[i], xmlns);
+          i++;
+        }
+        if (i < newNodesLength || i < oldNodesLength) {
+          const oldByKey = /* @__PURE__ */ new Map();
+          for (let k = i; k < oldNodesLength; k++) {
+            oldByKey.set(oldNodes[k].attrs.$key, oldNodes[k]);
+          }
+          const last = _lastRoot(oldNodes[oldNodesLength - 1]);
+          let next = last ? last.nextSibling : null;
+          for (let k = newNodesLength - 1; k >= i; k--) {
+            newNode = newNodes[k];
+            oldNode = oldByKey.get(newNode.attrs.$key);
+            if (oldNode) {
+              oldByKey.delete(newNode.attrs.$key);
+              if (newNode.is === VNODE_COMP && newNode.attrs.$remove) {
+                if (oldNode.$tag & FLAG_IS_REMOVING || !_remove(oldNode)) {
+                  oldNode.up = parentNode;
+                  newNodes[k] = oldNode;
+                } else {
+                  newNodes.splice(k, 1);
+                  continue;
+                }
+              } else {
+                _updateNode(parentNode, parentEl, newNode, oldNode, xmlns);
+              }
+            } else if (!newNode.attrs.$remove) {
+              _create(parentNode, parentEl, newNode, xmlns);
+            } else {
+              newNodes.splice(k, 1);
+              continue;
+            }
+            next = _place(newNodes[k], parentEl, next);
+          }
+          for (const oldNode2 of oldByKey.values()) _remove(oldNode2);
+        }
+      } else {
+        for (let i2 = newNodesLength; i2 < oldNodesLength; i2++) {
+          _remove(oldNodes[i2]);
+        }
+        for (let i2 = 0; i2 < newNodesLength; i2++) {
+          oldNode = oldNodes[i2];
+          newNode = newNodes[i2];
+          if (oldNode && oldNode.el) {
+            _updateNode(parentNode, parentEl, newNode, oldNode, xmlns);
+          } else {
+            _create(parentNode, parentEl, newNode, xmlns);
+          }
+        }
+      }
+    } else {
+      for (; i < newNodesLength; i++) {
+        _create(parentNode, parentEl, newNodes[i], xmlns);
+      }
+    }
+  } else {
+    if (parentNode.is === VNODE_ELEM) {
+      parentEl.textContent = "";
+      _unmount(oldNodes);
+    } else {
+      for (let i = 0; i < oldNodesLength; i++) _remove(oldNodes[i]);
+    }
+  }
+  parentNode.nodes = newNodes;
+};
+const _setElAttributes = (newNode, oldAttrs = ALWAYS_EMPTY_OBJECT) => {
+  let attr;
+  let valueType;
+  const el = newNode.el;
+  const newAttrs = newNode.attrs;
+  if (newNode.$tag === "input" && newAttrs.type) {
+    el.setAttribute("type", newAttrs.type);
+  }
+  for (attr in newAttrs) {
+    const value = newAttrs[attr];
+    if (attr[0] === "o" && attr[1] === "n") {
+      if (value !== oldAttrs[attr]) {
+        el[attr] = typeof value === "function" ? (e) => {
+          if (value.call(e.currentTarget, e) === false) {
+            e.preventDefault();
+            e.stopPropagation();
+          }
+          if (e.draw !== false) {
+            draw(newNode);
+          }
+        } : null;
+      }
+    } else if (attr[0] !== "$" && (attr !== "type" || newNode.$tag !== "input") && attr !== "is" && attr !== "xmlns") {
+      valueType = typeof value;
+      if (valueType === "string" || valueType === "number") {
+        if (attr === "value") {
+          if (value !== oldAttrs[attr]) el.value = value;
+        } else if (value !== oldAttrs[attr]) {
+          el.setAttribute(attr, value + "");
+        }
+      } else if (value === true) {
+        if (oldAttrs[attr] !== true) el.setAttribute(attr, attr);
+      } else if (!value) {
+        if (oldAttrs[attr]) el.removeAttribute(attr);
+      } else if (attr === "style") {
+        if (typeof oldAttrs.style === "string") {
+          el.removeAttribute("style");
+        } else {
+          for (const oldAttr in oldAttrs.style || ALWAYS_EMPTY_OBJECT) {
+            if (!(oldAttr in value)) {
+              el.style[oldAttr] = "";
+            }
+          }
+        }
+        Object.assign(el.style, value);
+      }
+    }
+  }
+  for (attr in oldAttrs) {
+    if (!(attr in newAttrs)) {
+      if (attr[0] === "o" && attr[1] === "n") {
+        el[attr] = null;
+      } else {
+        el.removeAttribute(attr);
+      }
+    }
+  }
+};
+const _create = (parentNode, parentEl, vNode, xmlns) => {
+  if (vNode.is === VNODE_ELEM) {
+    vNode.up = parentNode;
+    xmlns = vNode.attrs && vNode.attrs.xmlns || ns[vNode.$tag] || xmlns;
+    vNode.el = xmlns ? document.createElementNS(xmlns, vNode.$tag, vNode.attrs.is ? { is: vNode.attrs.is } : null) : document.createElement(vNode.$tag, vNode.attrs.is ? { is: vNode.attrs.is } : null);
+    _setElAttributes(vNode);
+    for (let i = 0; i < vNode.nodes.length; i++) {
+      _create(vNode, vNode.el, vNode.nodes[i], xmlns);
+    }
+    parentEl.insertBefore(vNode.el, null);
+  } else if (vNode.is === VNODE_TEXT) {
+    vNode = vNode;
+    vNode.el = document.createTextNode(vNode.$tag);
+    parentEl.insertBefore(vNode.el, null);
+  } else if (vNode.is === VNODE_COMP) {
+    vNode.up = parentNode;
+    if (vNode.$def.init) vNode.$def.init(vNode);
+    vNode.nodes = _flatten(vNode.$def.draw(vNode));
+    if (vNode.$tag & FLAG_HAS_LIFECYCLE) {
+      for (let current = vNode; current && !current.$h; current = current.up) {
+        current.$h = true;
+      }
+    }
+    if (vNode.attrs.to) {
+      if (!(vNode.attrs.to instanceof Element)) {
+        throw new Error('For components that act as portals, "to" attribute must be an Element');
+      }
+      vNode.el = document.createComment("");
+      parentEl.insertBefore(vNode.el, null);
+    }
+    for (let i = 0; i < vNode.nodes.length; i++) {
+      _create(vNode, vNode.attrs.to || parentEl, vNode.nodes[i], xmlns);
+    }
+    if (!vNode.el) vNode.el = vNode.nodes[0] && vNode.nodes[0].el;
+    if (vNode.$def.drawn) vNode.$def.drawn(vNode, true);
+  } else if (vNode.is === VNODE_NODE) {
+    parentEl.insertBefore(vNode.el, null);
+  }
+};
+const _redrawComponent = (vNode, parentEl, xmlns) => {
+  const oldChildren = vNode.nodes;
+  const newChildren = vNode.$def.draw(vNode, oldChildren);
+  vNode.$tag &= ~FLAG_IS_STALE;
+  if (newChildren !== oldChildren) {
+    _updateNodes(vNode, vNode.attrs.to || parentEl, _flatten(newChildren), oldChildren, xmlns);
+    if (!vNode.el) vNode.el = vNode.nodes[0] && vNode.nodes[0].el;
+  }
+  if (vNode.$def.drawn) vNode.$def.drawn(vNode);
+};
+const _unmountReusableArray = [];
+const _unmount = (nodes) => {
+  if (!Array.isArray(nodes)) {
+    _unmountReusableArray[0] = nodes;
+    nodes = _unmountReusableArray;
+  }
+  nodes = nodes;
+  for (let i = 0; i < nodes.length; i++) {
+    const node2 = nodes[i];
+    if (node2.is === VNODE_COMP) {
+      if (node2.$tag & FLAG_HAS_REMOVE || node2.$def.remove) {
+        if (!(node2.$tag & FLAG_REMOVE_CALLED)) {
+          node2.$def.remove(node2);
+        }
+      }
+      if (node2.$tag & FLAG_HAS_REMOVED || node2.$def.removed) {
+        node2.$def.removed(node2);
+      }
+    }
+    if (node2.$h && node2.nodes.length) {
+      _unmount(node2.nodes);
+      node2.nodes = null;
+    }
+    node2.attrs = node2.nodes = node2.$tag = node2.$def = node2.el = node2.up = null;
+  }
+};
+const _detach = (vNode) => {
+  if (vNode.is === VNODE_COMP) {
+    for (let i = 0; i < vNode.nodes.length; i++) {
+      _detach(vNode.nodes[i]);
+    }
+    if (vNode.attrs.to && vNode.el) vNode.el.remove();
+  } else if (vNode.el) {
+    vNode.el.remove();
+  }
+};
+const _destroy = (vNode) => {
+  _detach(vNode);
+  _unmount(vNode);
+};
+const _remove = (vNode) => {
+  if (vNode.is === VNODE_COMP) {
+    if (vNode.$tag & FLAG_HAS_REMOVE || vNode.$def.remove) {
+      if (vNode.$tag & FLAG_IS_REMOVING) {
+        return false;
+      }
+      vNode.$tag |= FLAG_REMOVE_CALLED | FLAG_IS_REMOVING;
+      const deferred = vNode.$def.remove(vNode);
+      if (deferred && deferred.then) {
+        if (!("$key" in vNode.attrs)) {
+          throw new Error(
+            "Component remove() returned a Promise but component has no $key attribute.\nDeferred removal requires a key to track the component during exit.\nAdd a $key and use $remove flag. Example:\ncomp(MyComponent, { $key: item.id, $remove: item.deleted })"
+          );
+        }
+        const deferredDestroy = () => {
+          if (vNode.$tag & FLAG_IS_REMOVING) {
+            const parent = vNode.up;
+            if (!parent) {
+              console.warn(
+                "Promise resolved but component was already removed.",
+                "This usually means the component was removed without using $remove attribute."
+              );
+              return;
+            }
+            if (parent) {
+              const i = parent.nodes.indexOf(vNode);
+              if (i !== -1) parent.nodes.splice(i, 1);
+            }
+            _destroy(vNode);
+            draw(parent);
+          }
+        };
+        deferred.then(deferredDestroy, deferredDestroy);
+        return false;
+      }
+    }
+  }
+  _destroy(vNode);
+  return true;
+};
+const elem = function(tag) {
+  const first = arguments[1];
+  const hasAttrs = first && typeof first === "object" && !Array.isArray(first) && !("$tag" in first);
+  return {
+    is: VNODE_ELEM,
+    $tag: tag,
+    // string: element name
+    $def: null,
+    // always null for elem
+    attrs: hasAttrs ? Object.freeze(first)  : ALWAYS_EMPTY_OBJECT,
+    nodes: arguments.length > (hasAttrs ? 2 : 1) ? _flatten(arguments, hasAttrs ? 2 : 1) : ALWAYS_EMPTY_ARRAY,
+    up: null,
+    el: null
+  };
+};
+const compDef = (componentDefinition) => {
+  {
+    if (!componentDefinition.draw) {
+      throw new Error("Component definition must have a draw function");
+    }
+    if (typeof componentDefinition.draw !== "function") {
+      throw new Error("draw must be a function");
+    }
+    if (componentDefinition.init && typeof componentDefinition.init !== "function") {
+      throw new Error("init must be a function");
+    }
+    if (componentDefinition.drawn && typeof componentDefinition.drawn !== "function") {
+      throw new Error("drawn must be a function");
+    }
+    if (componentDefinition.remove && typeof componentDefinition.remove !== "function") {
+      throw new Error("remove must be a function");
+    }
+    if (componentDefinition.removed && typeof componentDefinition.removed !== "function") {
+      throw new Error("removed must be a function");
+    }
+    if (componentDefinition.$memo !== void 0 && typeof componentDefinition.$memo !== "boolean" && typeof componentDefinition.$memo !== "function") {
+      throw new Error("$memo must be a boolean or function");
+    }
+  }
+  return Object.freeze({
+    is: VNODE_COMPDEF,
+    $tag: FLAG_IS_DEFINED | (componentDefinition.remove ? FLAG_HAS_REMOVE : 0) | (componentDefinition.removed ? FLAG_HAS_REMOVED : 0) | (componentDefinition.remove || componentDefinition.removed ? FLAG_HAS_LIFECYCLE : 0),
+    ...componentDefinition
+  });
+};
+const comp = (componentDefinition, attrs = ALWAYS_EMPTY_OBJECT) => {
+  return {
+    is: VNODE_COMP,
+    $tag: componentDefinition.$tag || 0,
+    // number: flags
+    $def: componentDefinition,
+    // object: component definition
+    attrs: attrs === ALWAYS_EMPTY_OBJECT ? attrs : Object.freeze(attrs) ,
+    nodes: ALWAYS_EMPTY_ARRAY,
+    up: null,
+    el: null
+  };
+};
+const node = (el) => {
+  return {
+    is: VNODE_NODE,
+    $tag: el.nodeName.toLowerCase(),
+    // string: element name
+    $def: null,
+    // always null for node
+    attrs: null,
+    nodes: null,
+    up: null,
+    el
+  };
+};
+const RootWrapper = compDef({
+  draw: (vNode) => vNode.attrs.$nodes
+});
+const bind = (el, vNodeAnyOrArray) => {
+  if (el == null) throw new Error("mount");
+  const rootComp = boundNodes.get(el) || comp(RootWrapper);
+  rootComp.attrs = { $nodes: vNodeAnyOrArray };
+  boundNodes.set(rootComp.el = el, rootComp);
+  draw(rootComp);
+  sync();
+  return rootComp;
+};
+
+export { bind, comp, compDef, diff, draw, elem, node, ns, sync };

package/dist/zenith.global.js

@@ -0,0 +1,2 @@
+/*! Zenith v1.0.0-beta.14 | MIT License | © 2022-2025 Daniel Barber */
+const e=new Map,t=new Set,ns={math:"http://www.w3.org/1998/Math/MathML",svg:"http://www.w3.org/2000/svg"},s=[],l={},n=new Map,sync=()=>{let s,l=t.size;if(l){const n=document.activeElement;for(const n of t)if(s=e.has(n.el)?n.el:n.attrs&&n.attrs.to||n.el&&n.el.parentNode||n.up&&n.up.el,t.delete(n),s&&g(n,s),! --l)break;t.size&&Promise.resolve().then(sync),n&&n!==document.activeElement&&"function"==typeof n.focus&&n.focus()}},draw=(e,s)=>{if(s)3===e.is&&(e.$tag|=2),t.add(e);else{let s;for(s=e;s.up;s=s.up);for(t.add(s),s=e;s.up;s=s.up)if(3===s.is){if(2&s.$tag)break;s.$tag|=2}}1===t.size&&Promise.resolve().then(sync)},r=[],o=(e,t=0,s=[])=>{let l;for(e&&"object"==typeof e&&null!=e.length||(r[0]=e,e=r);e.length>t;t++)if(l=e[t],Array.isArray(l))o(l,0,s);else if(null!=l)if(l.is){if(void 0===s.$keys)s.$keys=l.attrs&&"$key"in l.attrs?n:null;else if(!s.$keys!=!(l.attrs&&"$key"in l.attrs))throw Error("$keys");s.push(l)}else if(!0!==l&&!1!==l){if(void 0===s.$keys)s.$keys=null;else if(s.$keys)throw Error("$keys");s.push({is:2,$tag:l+"",$def:null,attrs:null,nodes:null,up:null,el:null})}return s},i=e=>{if(3===e.is&&!e.attrs.to){for(let t=e.nodes.length-1;t>=0;t--){const s=i(e.nodes[t]);if(s)return s}return null}return e.el},a=(e,t,s)=>{if(3!==e.is||e.attrs.to)e.el&&(e.el.nextSibling!==s&&t.insertBefore(e.el,s),s=e.el);else for(let l=e.nodes.length-1;l>=0;l--)s=a(e.nodes[l],t,s);return s},f=(e,t,s,l,n,r)=>{if(l.el){const o=s.is;if(o===l.is)if(1===o)if(s.up=e,s.$tag===l.$tag){s.el=l.el,s.$h=l.$h;const e=s.attrs.$diff||6;2&e&&$(s,l.attrs),4&e?d(s,s.el,s.nodes,l.nodes,s.attrs.xmlns||ns[s.$tag]||n):s.nodes=l.nodes}else u(e,t,s,n),t.insertBefore(s.el,l.el),h(l);else 2===o?(s.el=l.el,s.$tag!==l.$tag&&(s.el.textContent=s.$tag)):3===o?(4&l.$tag&&(l.$tag&=-5),s.up=e,s.$def===l.$def?(s.el=l.el,s.$h=l.$h,s.nodes=l.nodes,(r||2&l.$tag||!s.$def.$memo||(!0===s.$def.$memo?s.attrs!==l.attrs:!s.$def.$memo(s.attrs,l.attrs)))&&(s.$tag&=-3,g(s,t,n))):(u(e,t,s,n),h(l))):4===o&&s.el!==l.el&&(t.insertBefore(s.el,null),l.el.remove());else u(e,t,s,n),h(l)}else u(e,t,s,n)},d=(e,t,s,l,n,r=0)=>{const o=s.length,d=l.length;if(o){let r,$,g=0;if(d)if(s.$keys&&l.$keys){for(;o>g&&d>g&&s[g].attrs.$key===l[g].attrs.$key;)f(e,t,s[g],l[g],n),g++;if(o>g||d>g){const c=new Map;for(let e=g;d>e;e++)c.set(l[e].attrs.$key,l[e]);const m=i(l[d-1]);let p=m?m.nextSibling:null;for(let l=o-1;l>=g;l--){if($=s[l],r=c.get($.attrs.$key),r)if(c.delete($.attrs.$key),3===$.is&&$.attrs.$remove){if(!(4&r.$tag)&&h(r)){s.splice(l,1);continue}r.up=e,s[l]=r}else f(e,t,$,r,n);else{if($.attrs.$remove){s.splice(l,1);continue}u(e,t,$,n)}p=a(s[l],t,p)}for(const e of c.values())h(e)}}else{for(let e=o;d>e;e++)h(l[e]);for(let i=0;o>i;i++)r=l[i],$=s[i],r&&r.el?f(e,t,$,r,n):u(e,t,$,n)}else for(;o>g;g++)u(e,t,s[g],n)}else if(1===e.is)t.textContent="",m(l);else for(let e=0;d>e;e++)h(l[e]);e.nodes=s},$=(e,t=l)=>{let s,n;const r=e.el,o=e.attrs;for(s in"input"===e.$tag&&o.type&&r.setAttribute("type",o.type),o){const i=o[s];if("o"===s[0]&&"n"===s[1])i!==t[s]&&(r[s]="function"==typeof i?t=>{!1===i.call(t.currentTarget,t)&&(t.preventDefault(),t.stopPropagation()),!1!==t.draw&&draw(e)}:null);else if("$"!==s[0]&&("type"!==s||"input"!==e.$tag)&&"is"!==s&&"xmlns"!==s)if(n=typeof i,"string"===n||"number"===n)"value"===s?i!==t[s]&&(r.value=i):i!==t[s]&&r.setAttribute(s,i+"");else if(!0===i)!0!==t[s]&&r.setAttribute(s,s);else if(i){if("style"===s){if("string"==typeof t.style)r.removeAttribute("style");else for(const e in t.style||l)e in i||(r.style[e]="");Object.assign(r.style,i)}}else t[s]&&r.removeAttribute(s)}for(s in t)s in o||("o"===s[0]&&"n"===s[1]?r[s]=null:r.removeAttribute(s))},u=(e,t,s,l)=>{if(1===s.is){s.up=e,s.el=(l=s.attrs&&s.attrs.xmlns||ns[s.$tag]||l)?document.createElementNS(l,s.$tag,s.attrs.is?{is:s.attrs.is}:null):document.createElement(s.$tag,s.attrs.is?{is:s.attrs.is}:null),$(s);for(let e=0;s.nodes.length>e;e++)u(s,s.el,s.nodes[e],l);t.insertBefore(s.el,null)}else if(2===s.is)s.el=document.createTextNode(s.$tag),t.insertBefore(s.el,null);else if(3===s.is){if(s.up=e,s.$def.init&&s.$def.init(s),s.nodes=o(s.$def.draw(s)),8&s.$tag)for(let e=s;e&&!e.$h;e=e.up)e.$h=!0;s.attrs.to&&(s.el=document.createComment(""),t.insertBefore(s.el,null));for(let e=0;s.nodes.length>e;e++)u(s,s.attrs.to||t,s.nodes[e],l);s.el||(s.el=s.nodes[0]&&s.nodes[0].el),s.$def.drawn&&s.$def.drawn(s,!0)}else 4===s.is&&t.insertBefore(s.el,null)},g=(e,t,s)=>{const l=e.nodes,n=e.$def.draw(e,l);e.$tag&=-3,n!==l&&(d(e,e.attrs.to||t,o(n),l,s),e.el||(e.el=e.nodes[0]&&e.nodes[0].el)),e.$def.drawn&&e.$def.drawn(e)},c=[],m=e=>{Array.isArray(e)||(c[0]=e,e=c);for(let t=0;e.length>t;t++){const s=e[t];3===s.is&&((16&s.$tag||s.$def.remove)&&(64&s.$tag||s.$def.remove(s)),(32&s.$tag||s.$def.removed)&&s.$def.removed(s)),s.$h&&s.nodes.length&&(m(s.nodes),s.nodes=null),s.attrs=s.nodes=s.$tag=s.$def=s.el=s.up=null}},p=e=>{if(3===e.is){for(let t=0;e.nodes.length>t;t++)p(e.nodes[t]);e.attrs.to&&e.el&&e.el.remove()}else e.el&&e.el.remove()},y=e=>{p(e),m(e)},h=e=>{if(3===e.is&&(16&e.$tag||e.$def.remove)){if(4&e.$tag)return!1;e.$tag|=68;const t=e.$def.remove(e);if(t&&t.then){const s=()=>{if(4&e.$tag){const t=e.up;if(t){const s=t.nodes.indexOf(e);-1!==s&&t.nodes.splice(s,1)}y(e),draw(t)}};return t.then(s,s),!1}}return y(e),!0},compDef=e=>Object.freeze({is:5,$tag:1|(e.remove?16:0)|(e.removed?32:0)|(e.remove||e.removed?8:0),...e}),comp=(e,t=l)=>({is:3,$tag:e.$tag||0,$def:e,attrs:t,nodes:s,up:null,el:null}),v=compDef({draw:e=>e.attrs.$nodes});window.z={elem:function(e){const t=arguments[1],n=t&&"object"==typeof t&&!Array.isArray(t)&&!("$tag"in t);return{is:1,$tag:e,$def:null,attrs:n?t:l,nodes:arguments.length>(n?2:1)?o(arguments,n?2:1):s,up:null,el:null}},comp:comp,node:e=>({is:4,$tag:e.nodeName.toLowerCase(),$def:null,attrs:null,nodes:null,up:null,el:e}),compDef:compDef,bind:(t,s)=>{const l=e.get(t)||comp(v);return l.attrs={$nodes:s},e.set(l.el=t,l),draw(l),sync(),l},draw:draw,ns:ns,diff:{none:1,self:2,nodes:4,all:6}};

package/dist/zenith.js

@@ -0,0 +1,2 @@
+/*! Zenith v1.0.0-beta.14 | MIT License | © 2022-2025 Daniel Barber */
+const e=new Map,t=new Set,ns={math:"http://www.w3.org/1998/Math/MathML",svg:"http://www.w3.org/2000/svg"},diff={none:1,self:2,nodes:4,all:6},s=[],l={},n=new Map,sync=()=>{let s,l=t.size;if(l){const n=document.activeElement;for(const n of t)if(s=e.has(n.el)?n.el:n.attrs&&n.attrs.to||n.el&&n.el.parentNode||n.up&&n.up.el,t.delete(n),s&&g(n,s),! --l)break;t.size&&Promise.resolve().then(sync),n&&n!==document.activeElement&&"function"==typeof n.focus&&n.focus()}},draw=(e,s)=>{if(s)3===e.is&&(e.$tag|=2),t.add(e);else{let s;for(s=e;s.up;s=s.up);for(t.add(s),s=e;s.up;s=s.up)if(3===s.is){if(2&s.$tag)break;s.$tag|=2}}1===t.size&&Promise.resolve().then(sync)},r=[],o=(e,t=0,s=[])=>{let l;for(e&&"object"==typeof e&&null!=e.length||(r[0]=e,e=r);e.length>t;t++)if(l=e[t],Array.isArray(l))o(l,0,s);else if(null!=l)if(l.is){if(void 0===s.$keys)s.$keys=l.attrs&&"$key"in l.attrs?n:null;else if(!s.$keys!=!(l.attrs&&"$key"in l.attrs))throw Error("$keys");s.push(l)}else if(!0!==l&&!1!==l){if(void 0===s.$keys)s.$keys=null;else if(s.$keys)throw Error("$keys");s.push({is:2,$tag:l+"",$def:null,attrs:null,nodes:null,up:null,el:null})}return s},i=e=>{if(3===e.is&&!e.attrs.to){for(let t=e.nodes.length-1;t>=0;t--){const s=i(e.nodes[t]);if(s)return s}return null}return e.el},a=(e,t,s)=>{if(3!==e.is||e.attrs.to)e.el&&(e.el.nextSibling!==s&&t.insertBefore(e.el,s),s=e.el);else for(let l=e.nodes.length-1;l>=0;l--)s=a(e.nodes[l],t,s);return s},f=(e,t,s,l,n,r)=>{if(l.el){const o=s.is;if(o===l.is)if(1===o)if(s.up=e,s.$tag===l.$tag){s.el=l.el,s.$h=l.$h;const e=s.attrs.$diff||6;2&e&&d(s,l.attrs),4&e?$(s,s.el,s.nodes,l.nodes,s.attrs.xmlns||ns[s.$tag]||n):s.nodes=l.nodes}else u(e,t,s,n),t.insertBefore(s.el,l.el),h(l);else 2===o?(s.el=l.el,s.$tag!==l.$tag&&(s.el.textContent=s.$tag)):3===o?(4&l.$tag&&(l.$tag&=-5),s.up=e,s.$def===l.$def?(s.el=l.el,s.$h=l.$h,s.nodes=l.nodes,(r||2&l.$tag||!s.$def.$memo||(!0===s.$def.$memo?s.attrs!==l.attrs:!s.$def.$memo(s.attrs,l.attrs)))&&(s.$tag&=-3,g(s,t,n))):(u(e,t,s,n),h(l))):4===o&&s.el!==l.el&&(t.insertBefore(s.el,null),l.el.remove());else u(e,t,s,n),h(l)}else u(e,t,s,n)},$=(e,t,s,l,n,r=0)=>{const o=s.length,$=l.length;if(o){let r,d,g=0;if($)if(s.$keys&&l.$keys){for(;o>g&&$>g&&s[g].attrs.$key===l[g].attrs.$key;)f(e,t,s[g],l[g],n),g++;if(o>g||$>g){const c=new Map;for(let e=g;$>e;e++)c.set(l[e].attrs.$key,l[e]);const p=i(l[$-1]);let m=p?p.nextSibling:null;for(let l=o-1;l>=g;l--){if(d=s[l],r=c.get(d.attrs.$key),r)if(c.delete(d.attrs.$key),3===d.is&&d.attrs.$remove){if(!(4&r.$tag)&&h(r)){s.splice(l,1);continue}r.up=e,s[l]=r}else f(e,t,d,r,n);else{if(d.attrs.$remove){s.splice(l,1);continue}u(e,t,d,n)}m=a(s[l],t,m)}for(const e of c.values())h(e)}}else{for(let e=o;$>e;e++)h(l[e]);for(let i=0;o>i;i++)r=l[i],d=s[i],r&&r.el?f(e,t,d,r,n):u(e,t,d,n)}else for(;o>g;g++)u(e,t,s[g],n)}else if(1===e.is)t.textContent="",p(l);else for(let e=0;$>e;e++)h(l[e]);e.nodes=s},d=(e,t=l)=>{let s,n;const r=e.el,o=e.attrs;for(s in"input"===e.$tag&&o.type&&r.setAttribute("type",o.type),o){const i=o[s];if("o"===s[0]&&"n"===s[1])i!==t[s]&&(r[s]="function"==typeof i?t=>{!1===i.call(t.currentTarget,t)&&(t.preventDefault(),t.stopPropagation()),!1!==t.draw&&draw(e)}:null);else if("$"!==s[0]&&("type"!==s||"input"!==e.$tag)&&"is"!==s&&"xmlns"!==s)if(n=typeof i,"string"===n||"number"===n)"value"===s?i!==t[s]&&(r.value=i):i!==t[s]&&r.setAttribute(s,i+"");else if(!0===i)!0!==t[s]&&r.setAttribute(s,s);else if(i){if("style"===s){if("string"==typeof t.style)r.removeAttribute("style");else for(const e in t.style||l)e in i||(r.style[e]="");Object.assign(r.style,i)}}else t[s]&&r.removeAttribute(s)}for(s in t)s in o||("o"===s[0]&&"n"===s[1]?r[s]=null:r.removeAttribute(s))},u=(e,t,s,l)=>{if(1===s.is){s.up=e,s.el=(l=s.attrs&&s.attrs.xmlns||ns[s.$tag]||l)?document.createElementNS(l,s.$tag,s.attrs.is?{is:s.attrs.is}:null):document.createElement(s.$tag,s.attrs.is?{is:s.attrs.is}:null),d(s);for(let e=0;s.nodes.length>e;e++)u(s,s.el,s.nodes[e],l);t.insertBefore(s.el,null)}else if(2===s.is)s.el=document.createTextNode(s.$tag),t.insertBefore(s.el,null);else if(3===s.is){if(s.up=e,s.$def.init&&s.$def.init(s),s.nodes=o(s.$def.draw(s)),8&s.$tag)for(let e=s;e&&!e.$h;e=e.up)e.$h=!0;s.attrs.to&&(s.el=document.createComment(""),t.insertBefore(s.el,null));for(let e=0;s.nodes.length>e;e++)u(s,s.attrs.to||t,s.nodes[e],l);s.el||(s.el=s.nodes[0]&&s.nodes[0].el),s.$def.drawn&&s.$def.drawn(s,!0)}else 4===s.is&&t.insertBefore(s.el,null)},g=(e,t,s)=>{const l=e.nodes,n=e.$def.draw(e,l);e.$tag&=-3,n!==l&&($(e,e.attrs.to||t,o(n),l,s),e.el||(e.el=e.nodes[0]&&e.nodes[0].el)),e.$def.drawn&&e.$def.drawn(e)},c=[],p=e=>{Array.isArray(e)||(c[0]=e,e=c);for(let t=0;e.length>t;t++){const s=e[t];3===s.is&&((16&s.$tag||s.$def.remove)&&(64&s.$tag||s.$def.remove(s)),(32&s.$tag||s.$def.removed)&&s.$def.removed(s)),s.$h&&s.nodes.length&&(p(s.nodes),s.nodes=null),s.attrs=s.nodes=s.$tag=s.$def=s.el=s.up=null}},m=e=>{if(3===e.is){for(let t=0;e.nodes.length>t;t++)m(e.nodes[t]);e.attrs.to&&e.el&&e.el.remove()}else e.el&&e.el.remove()},y=e=>{m(e),p(e)},h=e=>{if(3===e.is&&(16&e.$tag||e.$def.remove)){if(4&e.$tag)return!1;e.$tag|=68;const t=e.$def.remove(e);if(t&&t.then){const s=()=>{if(4&e.$tag){const t=e.up;if(t){const s=t.nodes.indexOf(e);-1!==s&&t.nodes.splice(s,1)}y(e),draw(t)}};return t.then(s,s),!1}}return y(e),!0},elem=function(e){const t=arguments[1],n=t&&"object"==typeof t&&!Array.isArray(t)&&!("$tag"in t);return{is:1,$tag:e,$def:null,attrs:n?t:l,nodes:arguments.length>(n?2:1)?o(arguments,n?2:1):s,up:null,el:null}},compDef=e=>Object.freeze({is:5,$tag:1|(e.remove?16:0)|(e.removed?32:0)|(e.remove||e.removed?8:0),...e}),comp=(e,t=l)=>({is:3,$tag:e.$tag||0,$def:e,attrs:t,nodes:s,up:null,el:null}),node=e=>({is:4,$tag:e.nodeName.toLowerCase(),$def:null,attrs:null,nodes:null,up:null,el:e}),v=compDef({draw:e=>e.attrs.$nodes}),bind=(t,s)=>{const l=e.get(t)||comp(v);return l.attrs={$nodes:s},e.set(l.el=t,l),draw(l),sync(),l};export{bind,comp,compDef,diff,draw,elem,node,ns,sync};

package/package.json

@@ -1,11 +1,56 @@
 {
-    "name": "zenith",
-    "version": "0.0.1",
-    "description": "client side initialization",
-    "main": "index.js",
-    "keywords": [
-        "client side"
-    ],
-    "author": "Ryan Swanston <junkswanston@hotmail.com>",
-    "license": "ISC"
+  "name": "zenith",
+  "version": "1.0.0-beta.14",
+  "description": "Another front-end framework.",
+  "type": "module",
+  "main": "./dist/zenith.js",
+  "module": "./dist/zenith.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/zenith.js"
+    },
+    "./helpers": {
+      "types": "./dist/types/helpers/index.d.ts",
+      "default": "./dist/zenith-helpers.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "rollup --config && tsc && node scripts/after-build.mjs",
+    "lint": "eslint . --ext .ts",
+    "test": "vitest --run --coverage --reporter verbose",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aleph1/zenith.git"
+  },
+  "author": "Daniel Barber / Aleph1",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/aleph1/Zenith/issues"
+  },
+  "homepage": "https://github.com/aleph1/Zenith#readme",
+  "devDependencies": {
+    "@rollup/plugin-replace": "^4.0.0",
+    "@rollup/plugin-terser": "^1.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.71.2",
+    "@typescript-eslint/parser": "^8.71.2",
+    "@vitest/coverage-v8": "^4.0.14",
+    "@vitest/ui": "^4.0.14",
+    "brotli": "^1.3.3",
+    "eslint": "^8.57.1",
+    "jsdom": "^27.2.0",
+    "rollup": "^2.74.1",
+    "rollup-plugin-brotli": "^3.1.0",
+    "rollup-plugin-esbuild": "^6.2.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.14"
+  }
 }

package/index.js

@@ -1,7 +0,0 @@
-// zenith is a WIP
-
-function zenith(params){
-	return JSON.stringify(params, null, '\t')
-}
-
-module.exports = zenith

package/readme.md

@@ -1 +0,0 @@
-Zenith is a WIP client side initialization module