zenith 1.0.0-beta.14 → 1.0.0-rc.1

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

@@ -16,4 +16,6 @@ export interface DerivedSignal<T> extends Signal<T> {
  * // In component cleanup:
  * removed: () => fullName.destroy()
  */
-export declare const derived: <T>(fn: () => T, deps: Signal<any>[]) => DerivedSignal<T>;
+export declare const derived: <T>(fn: () => T, deps: {
+    sub(fn: () => void): () => void;
+}[]) => DerivedSignal<T>;

package/dist/types/helpers/detached-root.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Renders children into another DOM location using an independent
+ * Zenith root. Useful for modals, popovers, and overlays.
+ *
+ * Unlike native portals:
+ * - Children do not inherit the originating component's ancestry
+ *   or injected context.
+ * - Events follow the destination DOM tree.
+ * - An extra wrapper <div> is inserted into the target.
+ * - Rendering into the target is deferred to a microtask.
+ *
+ * The helper manages mounting, updates, and cleanup, but not
+ * stacking, positioning, focus, or accessibility.
+ *
+ * @example
+ * comp(DetachedRoot, {
+ *   to: document.body, // Or a CSS selector such as '#modals'
+ *   children: comp(Modal)
+ * });
+ */
+import type { VNodeCompAttributes, VNodeCompDefinition, VNodeAny, VNodeArray } from '../vnode.defs';
+interface DetachedRootAttrs extends VNodeCompAttributes {
+    to: string | Element;
+    children: VNodeAny | VNodeArray;
+}
+declare const definition: VNodeCompDefinition<DetachedRootAttrs>;
+export declare const DetachedRoot: typeof definition;
+export {};

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

@@ -10,4 +10,4 @@ export type { Signal } from './signal';
 export { derived } from './derived';
 export type { DerivedSignal } from './derived';
 export { router } from './router';
-export { Portal } from './portal';
+export { DetachedRoot } from './detached-root';

package/dist/types/index.d.ts

@@ -15,7 +15,10 @@ export declare const diff: {
     all: number;
 };
 export declare const sync: () => void;
-export declare const draw: (vNode: VNodeContainer, surgical?: boolean) => void;
+export declare const redraw: {
+    (vNode: VNodeContainer, surgical?: false): void;
+    (vNode: VNodeComp, surgical: true): void;
+};
 export declare const elem: {
     (tag: string): VNodeElem;
     (tag: string, attrs: VNodeElemAttributes, ...args: VNodeArray): VNodeElem;
@@ -24,5 +27,5 @@ export declare const elem: {
 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 declare const bind: (el: Element, vNodeAnyOrArray: VNodeAny | VNodeArray | null) => VNodeComp;
 export { ns };

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

@@ -1,8 +1,9 @@
 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 declare const VNODE_COMP = 4;
+export declare const VNODE_NODE = 8;
+export declare const VNODE_COMPDEF = 16;
+export declare const VNODE_TYPE_MASK = 31;
 export interface VNodeElemAttributes {
     class?: string | string[];
     style?: string | Record<string, string | number | null | undefined>;
@@ -16,15 +17,11 @@ export interface VNodeElemAttributes {
 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;
+    $t?: number;
     init?: (vNode: VNodeComp<A>) => void;
     draw: (vNode: VNodeComp<A>, oldChildren?: VNodeFlatArray) => VNodeAnyOrArray;
     drawn?: (vNode: VNodeComp<A>, isFirstDraw?: boolean) => void;
@@ -34,36 +31,39 @@ export interface VNodeCompDefinition<A extends VNodeCompAttributes = VNodeCompAt
 }
 interface VNodeBase {
     $h?: boolean;
-    up: VNodeContainer | null;
+    $p: VNodeContainer | null;
     nodes: VNodeFlatArray | null;
     el: any;
 }
 export interface VNodeElem extends VNodeBase {
     is: typeof VNODE_ELEM;
-    $tag: string;
-    $def: null;
+    $t: string;
+    $d: null;
     attrs: VNodeElemAttributes;
     nodes: VNodeFlatArray;
 }
 export interface VNodeText extends VNodeBase {
     is: typeof VNODE_TEXT;
-    $tag: string;
-    $def: null;
+    $t: string;
+    $d: null;
     attrs: null;
     nodes: null;
 }
 export interface VNodeComp<A extends VNodeCompAttributes = VNodeCompAttributes> extends VNodeBase {
     is: typeof VNODE_COMP;
-    $tag: number;
-    $def: VNodeCompDefinition;
+    $t: number;
+    $d: VNodeCompDefinition;
+    $r?: object | null;
     attrs: A;
     nodes: VNodeFlatArray;
     provide?: Record<string, any>;
+    /** Optional, application-managed instance state. */
+    state?: Record<string, any>;
 }
 export interface VNodeNode extends VNodeBase {
     is: typeof VNODE_NODE;
-    $tag: string;
-    $def: null;
+    $t: number;
+    $d: null;
     attrs: null;
     nodes: null;
 }
@@ -77,6 +77,6 @@ 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;
+    $keys?: boolean;
 }
 export {};