vasille-jsx 5.1.4 → 6.0.0-rc

package/lib/components.js

@@ -1,4 +1,8 @@
-import { ArrayModel, ArrayView, Fragment, MapModel, MapView, reportError, safe, SetModel, SetView, SwitchedNode, userError, Watch as CoreWatch, } from "vasille";
+import { ArrayModel, ArrayView as CoreArrayView, SinglePassArrayView, Fragment, MapModel, MapView as CoreMapView, reportError, safe, SetModel, SetView as CoreSetView, SwitchedNode, userError, Watch as CoreWatch, } from "vasille";
+import { ref } from "./internal.js";
+function frag(runner) {
+    return new Fragment(runner);
+}
 export function Slot({ model, slot, ...options }, ctx, defaultSlot) {
     try {
         if (model) {
@@ -24,27 +28,23 @@ export function For({ of: model, slot: _slot }, ctx, defaultSlot) {
         return;
     }
     if (model instanceof ArrayModel) {
-        ctx.create(new ArrayView({
-            model,
-            slot: slot,
-        }, ctx.runner));
+        ctx.create(new CoreArrayView(ctx.runner, model, (ctx, value, index) => {
+            slot(ctx, value, index.V);
+        }, ref, frag));
     }
     else if (model instanceof MapModel) {
-        ctx.create(new MapView({
-            model,
-            slot,
-        }, ctx.runner));
+        ctx.create(new CoreMapView(ctx.runner, model, (ctx, value, key) => {
+            slot(ctx, value.V, key);
+        }, ref, frag));
     }
     else if (model instanceof SetModel) {
-        ctx.create(new SetView({
-            model,
-            slot: slot,
-        }, ctx.runner));
+        ctx.create(new CoreSetView(ctx.runner, model, (ctx, value) => {
+            slot(ctx, value, value);
+        }, frag));
     }
     // fallback if is used external Array/Map/Set
     else {
         const safeSlot = safe(slot);
-        console.warn("Vasille <For of/> fallback detected. Please provide reactive data.");
         if (model instanceof Array) {
             model.forEach((value) => {
                 safeSlot(ctx, value, value);
@@ -56,7 +56,7 @@ export function For({ of: model, slot: _slot }, ctx, defaultSlot) {
             });
         }
         else if (model instanceof Set) {
-            model.forEach(value => {
+            model.forEach((value) => {
                 safeSlot(ctx, value, value);
             });
         }
@@ -65,6 +65,18 @@ export function For({ of: model, slot: _slot }, ctx, defaultSlot) {
         }
     }
 }
+export function ArrayView(props, ctx) {
+    ctx.create(new SinglePassArrayView(ctx.runner, props.of, props.key, props.slot, ref, ref, frag));
+}
+export function ArrayModelView(props, ctx) {
+    ctx.create(new CoreArrayView(ctx.runner, props.of, props.slot, ref, frag));
+}
+export function MapModelView(props, ctx) {
+    ctx.create(new CoreMapView(ctx.runner, props.of, props.slot, ref, frag));
+}
+export function SetModelView(props, ctx) {
+    ctx.create(new CoreSetView(ctx.runner, props.of, props.slot, frag));
+}
 export function Watch({ $model, slot: _slot }, ctx, defaultSlot) {
     const slot = _slot ?? defaultSlot;
     /* istanbul ignore else */

package/lib/dev/components.js

@@ -1,5 +1,5 @@
 import { safe, userError } from "vasille";
-import { DevArrayModel, DevArrayView, DevFragment, DevMapModel, DevMapView, DevSetModel, DevSetView, DevSwitchedNode, DevWatch as DevCoreWatch, errorToString, } from "vasille/dev";
+import { DevArrayModel, DevArrayView as DevCoreArrayView, DevFragment, DevMapModel, DevMapView, DevSetModel, DevSetView, DevSinglePassArrayView, DevSwitchedNode, DevWatch as DevCoreWatch, errorToString, } from "vasille/dev";
 export function DevSlot({ model, slot, ...options }, ctx, defaultSlot, usage) {
     try {
         if (model) {
@@ -27,31 +27,30 @@ export function DevSwitch(options, ctx, _slot, usage) {
 }
 export function DevFor({ of: model, slot: _slot }, ctx, defaultSlot, usage) {
     const slot = _slot ?? defaultSlot;
+    console.warn("Vasille <For of/> IS DEPRECATED. " +
+        "Please use ArrayView/ArrayModelView/SetModelView/MapModelView/Iterate/ForEach.");
     if (!slot) {
         return;
     }
     if (model instanceof DevArrayModel) {
-        ctx.create(new DevArrayView({
-            model,
-            slot: slot,
-        }, ctx.runner, usage));
+        ctx.create(new DevCoreArrayView(ctx.runner, model, (ctx, value, index) => {
+            slot(ctx, value, index.V);
+        }, usage));
     }
     else if (model instanceof DevMapModel) {
-        ctx.create(new DevMapView({
-            model,
-            slot,
-        }, ctx.runner, usage));
+        ctx.create(new DevMapView(ctx.runner, model, (ctx, value, key) => {
+            slot(ctx, value.V, key);
+        }, usage, undefined));
     }
     else if (model instanceof DevSetModel) {
-        ctx.create(new DevSetView({
-            model,
-            slot: slot,
-        }, ctx.runner, usage));
+        ctx.create(new DevSetView(ctx.runner, model, (ctx, value) => {
+            slot(ctx, value, value);
+        }, usage));
     }
     // fallback if is used external Array/Map/Set
     else {
         const safeSlot = safe(slot);
-        console.warn("Vasille <For of/> fallback detected. Please provide reactive data.");
+        console.warn("Vasille <For of/> fallback detected. Please use Iterate or ForEach.");
         if (model instanceof Array) {
             model.forEach((value) => {
                 safeSlot(ctx, value, value);
@@ -63,7 +62,7 @@ export function DevFor({ of: model, slot: _slot }, ctx, defaultSlot, usage) {
             });
         }
         else if (model instanceof Set) {
-            model.forEach(value => {
+            model.forEach((value) => {
                 safeSlot(ctx, value, value);
             });
         }
@@ -72,6 +71,18 @@ export function DevFor({ of: model, slot: _slot }, ctx, defaultSlot, usage) {
         }
     }
 }
+export function DevArrayView(props, ctx, usage, _defaultSlot, value, index) {
+    ctx.create(new DevSinglePassArrayView(ctx.runner, props.of, props.key, props.slot, usage, value, index));
+}
+export function DevArrayModelView(props, ctx, _defaultSlot, usage, index) {
+    ctx.create(new DevCoreArrayView(ctx.runner, props.of, props.slot, usage, index));
+}
+export function DevMapModelView(props, ctx, _defaultSlot, usage, value) {
+    ctx.create(new DevMapView(ctx.runner, props.of, props.slot, usage, value));
+}
+export function DevSetModelView(props, ctx, usage) {
+    ctx.create(new DevSetView(ctx.runner, props.of, props.slot, usage));
+}
 export function DevWatch({ $model, slot: _slot }, ctx, defaultSlot, usage) {
     const slot = _slot ?? defaultSlot;
     /* istanbul ignore else */

package/lib/dev/compose.js

@@ -1,17 +1,32 @@
+import { Fragment } from "vasille";
 import { DevReactive, errorToString, remapObject, toDevIdOrValue } from "vasille/dev";
 import { DevApp, DevFragment, ModelId } from "vasille/dev";
 import { earlyInspector } from "./early-inspector.js";
+export function devDynamicalModule(composed, fragments, safeRun) {
+    Object.defineProperties(composed, {
+        fragments: {
+            value: fragments,
+        },
+        recompose: {
+            value: function (previous) {
+                // inspector erase declaration
+                previous.forEach(({ props, node, usage }, key) => {
+                    node.children.forEach(child => child.destroy());
+                    node.children.splice(0);
+                    safeRun(node, props, usage);
+                    fragments.set(key, { props, node, usage });
+                });
+            },
+        },
+    });
+    return composed;
+}
 export function devView(renderer, declaration, name) {
-    return function (props, node, slot, usage) {
+    let fragments = new Map();
+    const safeRun = function (parent, props, usage) {
         const { callback } = props;
-        if (!node) {
-            throw new Error("Vasille: Component context is missing");
-        }
-        const frag = new DevFragment(node.runner, declaration, usage ?? null, name, props);
-        if (slot) {
-            props.slot = slot;
-        }
-        node.create(frag);
+        const frag = new DevFragment(parent.runner, declaration, usage ?? null, name, props);
+        parent.create(frag);
         try {
             const result = renderer(frag, props);
             if (result !== undefined && result !== null && callback) {
@@ -19,7 +34,7 @@ export function devView(renderer, declaration, name) {
             }
         }
         catch (e) {
-            node.runner.inspector.reportComponentError({
+            parent.runner.inspector.reportComponentError({
                 targetId: frag.id,
                 error: errorToString(e),
                 time: Date.now(),
@@ -27,12 +42,26 @@ export function devView(renderer, declaration, name) {
             reportError(e);
         }
         finally {
-            node.runner.inspector.composeTime({
+            parent.runner.inspector.composeTime({
                 id: frag.id,
                 time: Date.now(),
             });
         }
     };
+    const composed = function (props, node, slot, usage) {
+        if (!node) {
+            throw new Error("Vasille: Component context is missing");
+        }
+        const frag = new Fragment(node.runner);
+        if (slot) {
+            props.slot = slot;
+        }
+        node.create(frag);
+        fragments.set(frag, { props, node, usage });
+        frag.runOnDestroy(() => fragments.delete(frag));
+        safeRun(frag, props, usage);
+    };
+    return devDynamicalModule(composed, fragments, safeRun);
 }
 export function devStore(fn, declaration, name) {
     const reactive = new DevReactive({ inspector: earlyInspector });

package/lib/dev/early-inspector.js

@@ -26,6 +26,9 @@ export class AbstractInspector {
     destroy(data) {
         this.send(this.destroy.name, data);
     }
+    erase(data) {
+        this.send(this.erase.name, data);
+    }
     eventTrigger(call) {
         this.send(this.eventTrigger.name, call);
     }

package/lib/dev/index.js

@@ -1,8 +1,8 @@
 import { setErrorHandler as coreSetErrorHandler } from "vasille";
 import { errorToString } from "vasille/dev";
 import { earlyInspector } from "./early-inspector.js";
-export { DevDelay, DevWatch, DevFor, DevSwitch, DevSlot } from "./components.js";
-export { devStore, devModel, devMount, devView } from "./compose.js";
+export { DevDelay, DevWatch, DevFor, DevSwitch, DevSlot, DevSetModelView, DevMapModelView, DevArrayModelView, DevArrayView, } from "./components.js";
+export { devStore, devModel, devMount, devView, devDynamicalModule } from "./compose.js";
 export { devArrayModel, devMapModel, devEnsure, devExpr, devMatch, devSetModel, devRef, devSet } from "./internal.js";
 export { devAwaited } from "./library.js";
 export { AbstractInspector, EarlyInspector, earlyInspector } from "./early-inspector.js";

package/lib/index.js

@@ -1,5 +1,6 @@
-export { Delay, For, Slot, Watch, Switch } from "./components.js";
+export { Delay, For, Slot, Watch, Switch, ArrayView, ArrayModelView, SetModelView, MapModelView, } from "./components.js";
 export { view, mount, model, store } from "./compose.js";
 export { awaited } from "./library.js";
 export { ref, arrayModel, mapModel, expr, setModel, set, ensure, match } from "./internal.js";
+export { QueuedRender } from "./queue.js";
 export { setErrorHandler } from "vasille";

package/lib/queue.js

@@ -0,0 +1,47 @@
+import { Fragment, safe } from "vasille";
+let queueTimer = null;
+const queue = [];
+function processQueue() {
+    const startTime = Date.now();
+    let i = 0;
+    queueTimer = null;
+    for (; i < queue.length; i++) {
+        const { node, slot } = queue[i];
+        safe(slot)(node);
+        queue[i].done = true;
+        if (Date.now() - startTime >= 12) {
+            break;
+        }
+    }
+    queue.splice(0, i + 1);
+    if (queue.length > 0) {
+        queueTimer = setTimeout(processQueue, 6);
+    }
+}
+export function QueuedRender(props, ctx, defaultSlot) {
+    /* istanbul ignore else */
+    if (defaultSlot) {
+        const node = new Fragment(ctx.runner);
+        const item = { done: false, node: node, slot: defaultSlot };
+        // mount the newly created node to the parent
+        ctx.create(node);
+        if (props.priority === "high") {
+            queue.unshift(item);
+        }
+        else {
+            queue.push(item);
+        }
+        node.runOnDestroy(() => {
+            if (!item.done) {
+                const index = queue.indexOf(item);
+                /* istanbul ignore else */
+                if (index !== -1) {
+                    queue.splice(index, 1);
+                }
+            }
+        });
+        if (queueTimer === null) {
+            queueTimer = setTimeout(processQueue, 0);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vasille-jsx",
-  "version": "5.1.4",
+  "version": "6.0.0-rc",
   "description": "The same framework which is designed to build bulletproof frontends (JSX components)",
   "main": "lib/index.js",
   "exports": {
@@ -65,6 +65,6 @@
     "typescript-eslint": "^8.39.1"
   },
   "dependencies": {
-    "vasille": "^5.1.9"
+    "vasille": "6.0.0-rc.4"
   }
 }

package/types/components.d.ts

@@ -1,4 +1,4 @@
-import { Fragment, IValue } from "vasille";
+import { ArrayModel, Fragment, IValue, MapModel, SetModel } from "vasille";
 interface SlotOptions<Node, Element, TagOptions extends object, T extends object> {
     model?: (input: T, ctx: Fragment<Node, Element, TagOptions>) => void;
     slot?: (input: object, ctx: Fragment<Node, Element, TagOptions>) => void;
@@ -13,11 +13,17 @@ interface SwitchOptions<Node, Element, TagOptions extends object> {
     slot?: never;
 }
 export declare function Switch<Node, Element, TagOptions extends object>(options: SwitchOptions<Node, Element, TagOptions>, ctx: Fragment<Node, Element, TagOptions>): void;
-interface ForOptions<Node, Element, TagOptions extends object, T, K, V> {
+interface ForOptions<Node, Element, TagOptions extends object, T, Args extends unknown[]> {
     of: T;
-    slot?: (ctx: Fragment<Node, Element, TagOptions>, value: T, index: K) => void;
+    slot?: (ctx: Fragment<Node, Element, TagOptions>, ...args: Args) => void;
 }
-export declare function For<Node, Element, TagOptions extends object, T extends Set<unknown> | Map<unknown, unknown> | unknown[], K = T extends unknown[] ? number : T extends Set<infer R> ? R : T extends Map<infer R, unknown> ? R : never, V = T extends (infer R)[] ? R : T extends Set<infer R> ? R : T extends Map<unknown, infer R> ? R : never>({ of: model, slot: _slot }: ForOptions<Node, Element, TagOptions, T, K, V>, ctx: Fragment<Node, Element, TagOptions>, defaultSlot?: (ctx: Fragment<Node, Element, TagOptions>) => void): void;
+export declare function For<Node, Element, TagOptions extends object, T extends Set<unknown> | Map<unknown, unknown> | unknown[], K = T extends unknown[] ? number : T extends Set<infer R> ? R : T extends Map<infer R, unknown> ? R : never, V = T extends (infer R)[] ? R : T extends Set<infer R> ? R : T extends Map<unknown, infer R> ? R : never>({ of: model, slot: _slot }: ForOptions<Node, Element, TagOptions, T, [V, K]>, ctx: Fragment<Node, Element, TagOptions>, defaultSlot?: (ctx: Fragment<Node, Element, TagOptions>) => void): void;
+export declare function ArrayView<Node, Element, TagOptions extends object, T extends unknown[], V = T extends (infer R)[] ? R : never>(props: Required<ForOptions<Node, Element, TagOptions, IValue<V[]>, [IValue<V>, IValue<number>]>> & {
+    key: (value: V) => number | string;
+}, ctx: Fragment<Node, Element, TagOptions>): void;
+export declare function ArrayModelView<Node, Element, TagOptions extends object, V>(props: Required<ForOptions<Node, Element, TagOptions, ArrayModel<V>, [V, IValue<number>]>>, ctx: Fragment<Node, Element, TagOptions>): void;
+export declare function MapModelView<Node, Element, TagOptions extends object, K, V>(props: Required<ForOptions<Node, Element, TagOptions, MapModel<K, V>, [IValue<V>, K]>>, ctx: Fragment<Node, Element, TagOptions>): void;
+export declare function SetModelView<Node, Element, TagOptions extends object, V>(props: Required<ForOptions<Node, Element, TagOptions, SetModel<V>, [V]>>, ctx: Fragment<Node, Element, TagOptions>): void;
 interface WatchOptions<Node, Element, TagOptions extends object, T> {
     $model: IValue<T>;
     slot?: (ctx: Fragment<Node, Element, TagOptions>, value: T) => void;

package/types/dev/components.d.ts

@@ -1,5 +1,5 @@
-import { Fragment } from "vasille";
-import { DevIValue, StaticPosition } from "vasille/dev";
+import { Fragment, IValue } from "vasille";
+import { DevArrayModel, DevIValue, DevMapModel, DevSetModel, StaticPosition } from "vasille/dev";
 import { IDevRunner } from "vasille/dev";
 interface DevSlotOptions<Node, Element, TagOptions extends object, T extends object> {
     model?: (input: T, ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>) => void;
@@ -15,11 +15,17 @@ interface DevSwitchOptions<Node, Element, TagOptions extends object> {
     slot?: never;
 }
 export declare function DevSwitch<Node, Element, TagOptions extends object>(options: DevSwitchOptions<Node, Element, TagOptions>, ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, _slot: undefined, usage: StaticPosition): void;
-interface DevForOptions<Node, Element, TagOptions extends object, T, K, V> {
+interface DevForOptions<Node, Element, TagOptions extends object, T, Args extends unknown[]> {
     of: T;
-    slot?: (ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, value: T, index: K) => void;
+    slot?: (ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, ...args: Args) => void;
 }
-export declare function DevFor<Node, Element, TagOptions extends object, T extends Set<unknown> | Map<unknown, unknown> | unknown[], K = T extends unknown[] ? number : T extends Set<infer R> ? R : T extends Map<infer R, unknown> ? R : never, V = T extends (infer R)[] ? R : T extends Set<infer R> ? R : T extends Map<unknown, infer R> ? R : never>({ of: model, slot: _slot }: DevForOptions<Node, Element, TagOptions, T, K, V>, ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, defaultSlot: ((ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>) => void) | undefined, usage: StaticPosition): void;
+export declare function DevFor<Node, Element, TagOptions extends object, T extends Set<unknown> | Map<unknown, unknown> | unknown[], K = T extends unknown[] ? number : T extends Set<infer R> ? R : T extends Map<infer R, unknown> ? R : never, V = T extends (infer R)[] ? R : T extends Set<infer R> ? R : T extends Map<unknown, infer R> ? R : never>({ of: model, slot: _slot }: DevForOptions<Node, Element, TagOptions, T, [V, K]>, ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, defaultSlot: ((ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>) => void) | undefined, usage: StaticPosition): void;
+export declare function DevArrayView<Node, Element, TagOptions extends object, T extends unknown[], V = T extends (infer R)[] ? R : never>(props: Required<DevForOptions<Node, Element, TagOptions, IValue<V[]>, [IValue<V>, IValue<number>]>> & {
+    key: (value: V) => number | string;
+}, ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, usage: StaticPosition, _defaultSlot: never, value: StaticPosition | undefined, index: StaticPosition | undefined): void;
+export declare function DevArrayModelView<Node, Element, TagOptions extends object, V>(props: Required<DevForOptions<Node, Element, TagOptions, DevArrayModel<V>, [V, IValue<number>]>>, ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, _defaultSlot: never, usage: StaticPosition, index: StaticPosition | undefined): void;
+export declare function DevMapModelView<Node, Element, TagOptions extends object, K, V>(props: Required<DevForOptions<Node, Element, TagOptions, DevMapModel<K, V>, [IValue<V>, K]>>, ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, _defaultSlot: never, usage: StaticPosition, value: StaticPosition | undefined): void;
+export declare function DevSetModelView<Node, Element, TagOptions extends object, V>(props: Required<DevForOptions<Node, Element, TagOptions, DevSetModel<V>, [V]>>, ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, usage: StaticPosition): void;
 interface DevWatchOptions<Node, Element, TagOptions extends object, T> {
     $model: DevIValue<T>;
     slot?: (ctx: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, value: T) => void;

package/types/dev/compose.d.ts

@@ -6,6 +6,15 @@ import { DevRunner, DevTagOptions, Inspector } from "vasille/dev";
 export type DevComposed<Node, Element, TagOptions extends object, In extends CompositionProps, Out> = ($: In & {
     callback?(data: Out | undefined): void;
 }, node?: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, slot?: In["slot"], usage?: StaticPosition) => void;
+export type DevInput<In, Out> = In & {
+    callback?(data: Out | undefined): void;
+};
+export type DevFragmentMap<Node, Element, TagOptions extends object, In> = Map<Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, {
+    props: In;
+    node: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>;
+    usage: StaticPosition | undefined;
+}>;
+export declare function devDynamicalModule<T, Node, Element, TagOptions extends object, Props>(composed: T, fragments: DevFragmentMap<Node, Element, TagOptions, Props>, safeRun: (parent: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, props: Props, usage: StaticPosition | undefined) => void): T;
 export declare function devView<Node, Element, TagOptions extends object, In extends CompositionProps, Out>(renderer: (node: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, input: In) => Out, declaration: StaticPosition, name: string): DevComposed<Node, Element, TagOptions, In, Out>;
 export declare function devStore<Out extends object>(fn: (ctx: Reactive) => Out, declaration: StaticPosition, name: string): Out;
 export declare function devModel<In extends object, Out extends object>(fn: (ctx: DevReactive<IDevRunner<unknown, unknown, object>>, o: In) => Out, declaration: StaticPosition, name: string): (o: In, parent: Reactive | undefined, usage: StaticPosition) => Out;

package/types/dev/early-inspector.d.ts

@@ -1,4 +1,4 @@
-import { Inspector, ProtocolComponent, ProtocolCustomModel, ProtocolExecutionPosition, ProtocolExpression, ProtocolExpressionError, ProtocolExpressionUpdate, ProtocolModel, ProtocolModelUpdate, ProtocolNode, ProtocolParent, ProtocolReference, ProtocolReferenceError, ProtocolReferenceUpdate, ProtocolState, ProtocolStore, ProtocolTag, ProtocolRouterActionCall, ProtocolRouterStateChange, ProtocolRouterTargetResult, ProtocolRoutes, ProtocolSlotError, ProtocolFunctionCall, ProtocolFunctionResult, ProtocolFunctionError, ProtocolEventTrigger, ProtocolComposeTime, ProtocolError, DestroyData } from "vasille/dev";
+import { Inspector, ProtocolComponent, ProtocolCustomModel, ProtocolExecutionPosition, ProtocolExpression, ProtocolExpressionError, ProtocolExpressionUpdate, ProtocolModel, ProtocolModelUpdate, ProtocolNode, ProtocolParent, ProtocolReference, ProtocolReferenceError, ProtocolReferenceUpdate, ProtocolState, ProtocolStore, ProtocolTag, ProtocolRouterActionCall, ProtocolRouterStateChange, ProtocolRouterTargetResult, ProtocolRoutes, ProtocolSlotError, ProtocolFunctionCall, ProtocolFunctionResult, ProtocolFunctionError, ProtocolEventTrigger, ProtocolComposeTime, ProtocolError, DestroyData, EraseData } from "vasille/dev";
 export declare abstract class AbstractInspector implements Inspector {
     addContextState(state: ProtocolState): void;
     composeTime(time: ProtocolComposeTime): void;
@@ -9,6 +9,7 @@ export declare abstract class AbstractInspector implements Inspector {
     createStore(store: ProtocolStore): void;
     createTag(tag: ProtocolTag): void;
     destroy(data: DestroyData): void;
+    erase(data: EraseData): void;
     eventTrigger(call: ProtocolEventTrigger): void;
     functionCall(call: ProtocolFunctionCall): void;
     functionReturn(result: ProtocolFunctionResult): void;

package/types/dev/index.d.ts

@@ -1,5 +1,5 @@
-export { DevDelay, DevWatch, DevFor, DevSwitch, DevSlot } from "./components.js";
-export { devStore, type DevComposed, devModel, devMount, devView } from "./compose.js";
+export { DevDelay, DevWatch, DevFor, DevSwitch, DevSlot, DevSetModelView, DevMapModelView, DevArrayModelView, DevArrayView, } from "./components.js";
+export { devStore, type DevComposed, devModel, devMount, devView, devDynamicalModule } from "./compose.js";
 export { devArrayModel, devMapModel, devEnsure, devExpr, devMatch, devSetModel, devRef, devSet } from "./internal.js";
 export { devAwaited } from "./library.js";
 export { AbstractInspector, EarlyInspector, earlyInspector } from "./early-inspector.js";

package/types/index.d.ts

@@ -1,5 +1,6 @@
-export { Delay, For, Slot, Watch, Switch } from "./components.js";
+export { Delay, For, Slot, Watch, Switch, ArrayView, ArrayModelView, SetModelView, MapModelView, } from "./components.js";
 export { view, mount, model, store, type Composed, type CompositionProps } from "./compose.js";
 export { awaited } from "./library.js";
 export { ref, arrayModel, mapModel, expr, setModel, set, ensure, match } from "./internal.js";
+export { type QueuedRenderProps, type QueueItem, QueuedRender } from "./queue.js";
 export { setErrorHandler } from "vasille";

package/types/queue.d.ts

@@ -0,0 +1,10 @@
+import { Fragment } from "vasille";
+export type QueueItem<Node, Element, TagOptions extends object> = {
+    node: Fragment<Node, Element, TagOptions>;
+    slot: (ctx: Fragment<Node, Element, TagOptions>) => void;
+    done: boolean;
+};
+export interface QueuedRenderProps {
+    priority?: "high" | "low";
+}
+export declare function QueuedRender<Node, Element, TagOptions extends object>(props: QueuedRenderProps, ctx: Fragment<Node, Element, TagOptions>, defaultSlot?: (ctx: Fragment<Node, Element, TagOptions>) => void): void;