reactronic 0.94.25029 → 0.94.25031

package/README.md

@@ -231,7 +231,7 @@ class Component<P> extends React.Component<P> {
   }
 
   componentWillUnmount(): void {
-    atomicAction(ReactiveSystem.dispose, this)
+    atomicAction(disposeObservableObject, this)
   }
 }
 ```

package/build/dist/source/Pipe.js

@@ -1,4 +1,5 @@
+import { misuse } from "./util/Dbg.js";
 import { ObservableObject } from "./core/Mvcc.js";
 export class Pipe extends ObservableObject {
-    static create(hint, capacity) { throw new Error("not implemented"); }
+    static create(hint, capacity) { throw misuse("not implemented"); }
 }

package/build/dist/source/Ref.js

@@ -1,3 +1,4 @@
+import { misuse } from "./util/Dbg.js";
 import { runAtomically, runNonReactively } from "./System.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
@@ -34,7 +35,7 @@ export class Ref {
         return this.variable;
     }
     unobserve() {
-        throw new Error("not implemented");
+        throw misuse("not implemented");
     }
     static sameRefs(v1, v2) {
         return v1.owner === v2.owner && v1.name === v2.name && v1.index === v2.index;

package/build/dist/source/System.js

@@ -1,4 +1,4 @@
-import { Log } from "./util/Dbg.js";
+import { Log, misuse } from "./util/Dbg.js";
 import { Kind, Isolation } from "./Enums.js";
 import { Meta, ObjectHandle } from "./core/Data.js";
 import { Changeset } from "./core/Changeset.js";
@@ -39,7 +39,7 @@ export function runSensitively(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
 }
 export function runContextually(p) {
-    throw new Error("not implemented yet");
+    throw misuse("not implemented yet");
 }
 export function manageReactiveOperation(method) {
     return ReactiveOperationImpl.manageReactiveOperation(method);

package/build/dist/source/api.d.ts

@@ -1,4 +1,5 @@
 export { all, pause, proceedSyncOrAsync } from "./util/Utils.js";
+export { Uri } from "./util/Uri.js";
 export { MergeList } from "./util/MergeList.js";
 export type { MergedItem, MergeListReader } from "./util/MergeList.js";
 export { SealedArray } from "./util/SealedArray.js";
@@ -20,5 +21,5 @@ export { Journal } from "./core/Journal.js";
 export { runAtomically, runNonReactively, runSensitively, runContextually, manageReactiveOperation, configureCurrentReactiveOperation, disposeObservableObject } from "./System.js";
 export { ReactiveSystem, observable, atomic, reactive, cached, options } from "./System.js";
 export { ReactiveOperationEx } from "./OperationEx.js";
-export { ReactiveTree, ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
+export { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
 export type { Script, ScriptAsync, Handler, ReactiveTreeNodeDecl, ReactiveTreeNodeDriver, ReactiveTreeNodeContext } from "./core/TreeNode.js";

package/build/dist/source/api.js

@@ -1,4 +1,5 @@
 export { all, pause, proceedSyncOrAsync } from "./util/Utils.js";
+export { Uri } from "./util/Uri.js";
 export { MergeList } from "./util/MergeList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
@@ -16,4 +17,4 @@ export { Journal } from "./core/Journal.js";
 export { runAtomically, runNonReactively, runSensitively, runContextually, manageReactiveOperation, configureCurrentReactiveOperation, disposeObservableObject } from "./System.js";
 export { ReactiveSystem, observable, atomic, reactive, cached, options } from "./System.js";
 export { ReactiveOperationEx } from "./OperationEx.js";
-export { ReactiveTree, ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
+export { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";

package/build/dist/source/core/Journal.js

@@ -1,3 +1,4 @@
+import { misuse } from "../util/Dbg.js";
 import { Isolation } from "../Enums.js";
 import { ObservableObject } from "./Mvcc.js";
 import { Meta, ContentFootprint } from "./Data.js";
@@ -38,7 +39,7 @@ export class JournalImpl extends Journal {
         if (this._unsaved === patch)
             this._unsaved = new Map();
         else
-            throw new Error("not implemented");
+            throw misuse("not implemented");
     }
     undo(count = 1) {
         Transaction.run({ hint: "Journal.undo", isolation: Isolation.disjoinFromOuterAndInnerTransactions }, () => {

package/build/dist/source/core/TreeNode.d.ts

@@ -6,23 +6,11 @@ import { ObservableObject } from "../core/Mvcc.js";
 export type Script<E> = (el: E, basis: () => void) => void;
 export type ScriptAsync<E> = (el: E, basis: () => Promise<void>) => Promise<void>;
 export type Handler<E = unknown, R = void> = (el: E) => R;
-export declare class ReactiveTree {
-    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-    static withBasis<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
-    static get isFirstScriptRun(): boolean;
-    static triggerScriptRun(node: ReactiveTreeNode<any>, triggers: unknown): void;
-    static triggerFinalization(node: ReactiveTreeNode<any>): void;
-    static runNestedNodeScriptsThenDo(action: (error: unknown) => void): void;
-    static markAsMounted(node: ReactiveTreeNode<any>, yes: boolean): void;
-    static findMatchingHost<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
-    static findMatchingPrevSibling<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
-    static forEachChildRecursively<E = unknown>(node: ReactiveTreeNode<E>, action: Handler<ReactiveTreeNode<E>>): void;
-    static getDefaultLoggingOptions(): LoggingOptions | undefined;
-    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
-}
 export declare abstract class ReactiveTreeNode<E = unknown> {
+    static readonly shortFrameDuration = 16;
+    static readonly longFrameDuration = 300;
+    static frameDuration: number;
+    static currentScriptPriority: Priority;
     abstract readonly key: string;
     abstract readonly driver: ReactiveTreeNodeDriver<E>;
     abstract readonly declaration: Readonly<ReactiveTreeNodeDecl<E>>;
@@ -38,16 +26,25 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     abstract priority?: Priority;
     abstract childrenShuffling: boolean;
     abstract strictOrder: boolean;
+    abstract getUri(relativeTo?: ReactiveTreeNode<any>): string;
     abstract has(mode: Mode): boolean;
-    abstract configureReactronic(options: Partial<ReactivityOptions>): ReactivityOptions;
-    static get key(): string;
-    static get stamp(): number;
-    static get triggers(): unknown;
-    static get priority(): Priority;
-    static set priority(value: Priority);
-    static get childrenShuffling(): boolean;
-    static set childrenShuffling(value: boolean);
-    static get effectiveScriptPriority(): Priority;
+    abstract configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
+    static get current(): ReactiveTreeNode;
+    static get isFirstScriptRun(): boolean;
+    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+    static withBasis<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
+    static triggerScriptRun(node: ReactiveTreeNode<any>, triggers: unknown): void;
+    static triggerFinalization(node: ReactiveTreeNode<any>): void;
+    static runNestedNodeScriptsThenDo(action: (error: unknown) => void): void;
+    static markAsMounted(node: ReactiveTreeNode<any>, yes: boolean): void;
+    lookupTreeNodeByUri<E = unknown>(uri: string): ReactiveTreeNode<E> | undefined;
+    static findMatchingHost<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
+    static findMatchingPrevSibling<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
+    static forEachChildRecursively<E = unknown>(node: ReactiveTreeNode<E>, action: Handler<ReactiveTreeNode<E>>): void;
+    static getDefaultLoggingOptions(): LoggingOptions | undefined;
+    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
 export type ReactiveTreeNodeDecl<E = unknown> = {
     script?: Script<E>;
@@ -95,7 +92,7 @@ export declare class ReactiveTreeVariable<T extends Object = Object> {
     get value(): T;
     get valueOrUndefined(): T | undefined;
 }
-export declare function generateKey(owner: ReactiveTreeNodeImpl): string;
+export declare function generateKey(owner?: ReactiveTreeNodeImpl): string;
 export declare function getModeUsingBasisChain(declaration?: ReactiveTreeNodeDecl<any>): Mode;
 declare class ReactiveTreeNodeContextImpl<T extends Object = Object> extends ObservableObject implements ReactiveTreeNodeContext<T> {
     next: ReactiveTreeNodeContextImpl<object> | undefined;
@@ -107,10 +104,6 @@ declare class ReactiveTreeNodeImpl<E = unknown> extends ReactiveTreeNode<E> {
     static logging: LoggingOptions | undefined;
     static grandNodeCount: number;
     static disposableNodeCount: number;
-    static readonly shortFrameDuration = 16;
-    static readonly longFrameDuration = 300;
-    static currentScriptPriority: Priority;
-    static frameDuration: number;
     readonly key: string;
     readonly driver: ReactiveTreeNodeDriver<E>;
     declaration: ReactiveTreeNodeDecl<E>;
@@ -127,16 +120,17 @@ declare class ReactiveTreeNodeImpl<E = unknown> extends ReactiveTreeNode<E> {
     priority: Priority;
     childrenShuffling: boolean;
     constructor(key: string, driver: ReactiveTreeNodeDriver<E>, declaration: Readonly<ReactiveTreeNodeDecl<E>>, owner: ReactiveTreeNodeImpl | undefined);
+    getUri(relativeTo?: ReactiveTreeNode<any>): string;
     get strictOrder(): boolean;
     set strictOrder(value: boolean);
     get isMoved(): boolean;
     has(mode: Mode): boolean;
     script(_triggers: unknown): void;
-    configureReactronic(options: Partial<ReactivityOptions>): ReactivityOptions;
+    configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
     static get nodeSlot(): MergedItem<ReactiveTreeNodeImpl>;
-    static tryUseNodeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;
-    static useNodeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T;
-    static setNodeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>, value: T | undefined): void;
+    static tryUseTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;
+    static useTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T;
+    static setTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>, value: T | undefined): void;
 }
 export declare function observablesAreEqual(a1: any, a2: any): boolean;
 export {};

package/build/dist/source/core/TreeNode.js

@@ -17,13 +17,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { misuse } from "../util/Dbg.js";
+import { Uri } from "../util/Uri.js";
 import { MergeList } from "../util/MergeList.js";
 import { emitLetters, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js";
 import { Priority, Mode, Isolation, Reentrance } from "../Enums.js";
 import { ObservableObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
 import { ReactiveSystem, options, observable, reactive, runAtomically, runNonReactively, manageReactiveOperation, disposeObservableObject } from "../System.js";
-export class ReactiveTree {
+export class ReactiveTreeNode {
+    static get current() {
+        return ReactiveTreeNodeImpl.nodeSlot.instance;
+    }
+    static get isFirstScriptRun() {
+        return ReactiveTreeNode.current.stamp === 1;
+    }
     static declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
         let result;
         let declaration;
@@ -44,7 +51,7 @@ export class ReactiveTree {
             if (existing) {
                 result = existing.instance;
                 if (result.driver !== driver && driver !== undefined)
-                    throw new Error(`changing element driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
+                    throw misuse(`changing element driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
                 const exTriggers = result.declaration.triggers;
                 if (observablesAreEqual(declaration.triggers, exTriggers))
                     declaration.triggers = exTriggers;
@@ -56,7 +63,7 @@ export class ReactiveTree {
             }
         }
         else {
-            result = new ReactiveTreeNodeImpl(effectiveKey || "", driver, declaration, owner);
+            result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
             result.slot = MergeList.createItem(result);
             triggerScriptRunViaSlot(result.slot);
         }
@@ -69,9 +76,6 @@ export class ReactiveTree {
             declaration = basis !== null && basis !== void 0 ? basis : {};
         return declaration;
     }
-    static get isFirstScriptRun() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.stamp === 1;
-    }
     static triggerScriptRun(node, triggers) {
         const impl = node;
         const declaration = impl.declaration;
@@ -90,11 +94,22 @@ export class ReactiveTree {
     static markAsMounted(node, yes) {
         const n = node;
         if (n.stamp < 0)
-            throw new Error("deactivated node cannot be mounted or unmounted");
+            throw misuse("deactivated node cannot be mounted or unmounted");
         if (n.stamp >= Number.MAX_SAFE_INTEGER)
-            throw new Error("node must be activated before mounting");
+            throw misuse("node must be activated before mounting");
         n.stamp = yes ? 0 : Number.MAX_SAFE_INTEGER - 1;
     }
+    lookupTreeNodeByUri(uri) {
+        var _a;
+        const t = Uri.parse(uri);
+        if (t.authority !== this.key)
+            throw misuse(`authority '${t.authority}' doesn't match root node key '${this.key}'`);
+        const segments = t.path.split("/");
+        let result = this;
+        for (let i = 1; i < segments.length && result !== undefined; i++)
+            result = (_a = result.children.lookup(segments[i])) === null || _a === void 0 ? void 0 : _a.instance;
+        return result;
+    }
     static findMatchingHost(node, match) {
         let p = node.host;
         while (p !== p.host && !match(p))
@@ -110,7 +125,7 @@ export class ReactiveTree {
     static forEachChildRecursively(node, action) {
         action(node);
         for (const child of node.children.items())
-            ReactiveTree.forEachChildRecursively(child.instance, action);
+            ReactiveTreeNode.forEachChildRecursively(child.instance, action);
     }
     static getDefaultLoggingOptions() {
         return ReactiveTreeNodeImpl.logging;
@@ -119,32 +134,10 @@ export class ReactiveTree {
         ReactiveTreeNodeImpl.logging = logging;
     }
 }
-export class ReactiveTreeNode {
-    static get key() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.key;
-    }
-    static get stamp() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.stamp;
-    }
-    static get triggers() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.declaration.triggers;
-    }
-    static get priority() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.priority;
-    }
-    static set priority(value) {
-        ReactiveTreeNodeImpl.nodeSlot.instance.priority = value;
-    }
-    static get childrenShuffling() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance.childrenShuffling;
-    }
-    static set childrenShuffling(value) {
-        ReactiveTreeNodeImpl.nodeSlot.instance.childrenShuffling = value;
-    }
-    static get effectiveScriptPriority() {
-        return ReactiveTreeNodeImpl.currentScriptPriority;
-    }
-}
+ReactiveTreeNode.shortFrameDuration = 16;
+ReactiveTreeNode.longFrameDuration = 300;
+ReactiveTreeNode.frameDuration = ReactiveTreeNode.longFrameDuration;
+ReactiveTreeNode.currentScriptPriority = Priority.realtime;
 export class BaseDriver {
     constructor(name, isPartition, initialize) {
         this.name = name;
@@ -177,17 +170,17 @@ export class ReactiveTreeVariable {
         this.defaultValue = defaultValue;
     }
     set value(value) {
-        ReactiveTreeNodeImpl.setNodeVariableValue(this, value);
+        ReactiveTreeNodeImpl.setTreeVariableValue(this, value);
     }
     get value() {
-        return ReactiveTreeNodeImpl.useNodeVariableValue(this);
+        return ReactiveTreeNodeImpl.useTreeVariableValue(this);
     }
     get valueOrUndefined() {
-        return ReactiveTreeNodeImpl.tryUseNodeVariableValue(this);
+        return ReactiveTreeNodeImpl.tryUseTreeVariableValue(this);
     }
 }
 export function generateKey(owner) {
-    const n = owner.numerator++;
+    const n = owner !== undefined ? owner.numerator++ : 0;
     const lettered = emitLetters(n);
     let result;
     if (ReactiveSystem.isLogging)
@@ -285,40 +278,56 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
         if (this.has(Mode.autonomous))
             ReactiveTreeNodeImpl.disposableNodeCount++;
     }
-    get strictOrder() { return this.children.isStrict; }
-    set strictOrder(value) { this.children.isStrict = value; }
-    get isMoved() { return this.owner.children.isMoved(this.slot); }
+    getUri(relativeTo) {
+        const path = [];
+        const authority = gatherAuthorityAndPath(this, path);
+        const result = Uri.from({
+            scheme: "node",
+            authority,
+            path: "/" + path.join("/"),
+        });
+        return result.toString();
+    }
+    get strictOrder() {
+        return this.children.isStrict;
+    }
+    set strictOrder(value) {
+        this.children.isStrict = value;
+    }
+    get isMoved() {
+        return this.owner.children.isMoved(this.slot);
+    }
     has(mode) {
         return (getModeUsingBasisChain(this.declaration) & mode) === mode;
     }
     script(_triggers) {
         runScriptNow(this.slot);
     }
-    configureReactronic(options) {
+    configureReactivity(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.autonomous))
-            throw new Error("reactronic can be configured only for elements with autonomous mode and only during activation");
+            throw misuse("reactronic can be configured only for elements with autonomous mode and only during preparation");
         return manageReactiveOperation(this.script).configure(options);
     }
     static get nodeSlot() {
         if (!gNodeSlot)
-            throw new Error("current element is undefined");
+            throw misuse("current element is undefined");
         return gNodeSlot;
     }
-    static tryUseNodeVariableValue(variable) {
+    static tryUseTreeVariableValue(variable) {
         var _a, _b;
         let node = ReactiveTreeNodeImpl.nodeSlot.instance;
         while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
             node = node.outer.slot.instance;
         return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
-    static useNodeVariableValue(variable) {
+    static useTreeVariableValue(variable) {
         var _a;
-        const result = (_a = ReactiveTreeNodeImpl.tryUseNodeVariableValue(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
+        const result = (_a = ReactiveTreeNodeImpl.tryUseTreeVariableValue(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
         if (!result)
-            throw new Error("unknown node variable");
+            throw misuse("unknown node variable");
         return result;
     }
-    static setNodeVariableValue(variable, value) {
+    static setTreeVariableValue(variable, value) {
         const node = ReactiveTreeNodeImpl.nodeSlot.instance;
         const owner = node.owner;
         const hostCtx = runNonReactively(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
@@ -346,10 +355,6 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
 ReactiveTreeNodeImpl.logging = undefined;
 ReactiveTreeNodeImpl.grandNodeCount = 0;
 ReactiveTreeNodeImpl.disposableNodeCount = 0;
-ReactiveTreeNodeImpl.shortFrameDuration = 16;
-ReactiveTreeNodeImpl.longFrameDuration = 300;
-ReactiveTreeNodeImpl.currentScriptPriority = Priority.realtime;
-ReactiveTreeNodeImpl.frameDuration = ReactiveTreeNodeImpl.longFrameDuration;
 __decorate([
     reactive,
     options({
@@ -362,6 +367,16 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
 ], ReactiveTreeNodeImpl.prototype, "script", null);
+function gatherAuthorityAndPath(node, path, relativeTo) {
+    let authority;
+    if (node.owner !== node && node.owner !== relativeTo) {
+        authority = gatherAuthorityAndPath(node.owner, path);
+        path.push(node.key);
+    }
+    else
+        authority = node.key;
+    return authority;
+}
 function getNodeKey(node) {
     return node.stamp >= 0 ? node.key : undefined;
 }
@@ -442,8 +457,8 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
             try {
                 if (node.childrenShuffling)
                     shuffle(items);
-                const frameDurationLimit = priority === Priority.background ? ReactiveTreeNodeImpl.shortFrameDuration : Infinity;
-                let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveTreeNodeImpl.frameDuration / 4, ReactiveTreeNodeImpl.shortFrameDuration));
+                const frameDurationLimit = priority === Priority.background ? ReactiveTreeNode.shortFrameDuration : Infinity;
+                let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveTreeNode.frameDuration / 4, ReactiveTreeNode.shortFrameDuration));
                 for (const child of items) {
                     triggerScriptRunViaSlot(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
@@ -451,9 +466,9 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
                         yield Transaction.requestNextFrame(0);
                         outerPriority = ReactiveTreeNodeImpl.currentScriptPriority;
                         ReactiveTreeNodeImpl.currentScriptPriority = priority;
-                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveTreeNodeImpl.frameDuration));
+                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveTreeNode.frameDuration));
                     }
-                    if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveTreeNodeImpl.shortFrameDuration / 3))
+                    if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveTreeNode.shortFrameDuration / 3))
                         break;
                 }
             }

package/build/dist/source/util/MergeList.js

@@ -1,3 +1,4 @@
+import { misuse } from "./Dbg.js";
 export class MergeList {
     constructor(getKey, strict = false) {
         this.getKey = getKey;
@@ -13,7 +14,7 @@ export class MergeList {
     get isStrict() { return this.strict; }
     set isStrict(value) {
         if (this.isMergeInProgress && this.current.count > 0)
-            throw new Error("cannot change strict mode in the middle of merge");
+            throw misuse("cannot change strict mode in the middle of merge");
         this.strict = value;
     }
     get count() {
@@ -46,7 +47,7 @@ export class MergeList {
     tryMergeAsExisting(key, resolution, error) {
         const tag = this.tag;
         if (tag < 0)
-            throw new Error(error !== null && error !== void 0 ? error : "merge is not in progress");
+            throw misuse(error !== null && error !== void 0 ? error : "merge is not in progress");
         let item = this.strictNextItem;
         if (key !== (item ? this.getKey(item.instance) : undefined))
             item = this.lookup(key);
@@ -65,7 +66,7 @@ export class MergeList {
             else if (resolution)
                 resolution.isDuplicate = true;
             else
-                throw new Error(`duplicate collection item: ${key}`);
+                throw misuse(`duplicate collection item: ${key}`);
         }
         else if (resolution)
             resolution.isDuplicate = false;
@@ -74,7 +75,7 @@ export class MergeList {
     mergeAsAdded(instance) {
         const key = this.getKey(instance);
         if (this.lookup(key) !== undefined)
-            throw new Error(`key is already in use: ${key}`);
+            throw misuse(`key is already in use: ${key}`);
         let tag = this.tag;
         if (tag < 0) {
             tag = ~this.tag + 1;
@@ -98,11 +99,11 @@ export class MergeList {
         }
     }
     move(item, after) {
-        throw new Error("not implemented");
+        throw misuse("not implemented");
     }
     beginMerge() {
         if (this.isMergeInProgress)
-            throw new Error("merge is in progress already");
+            throw misuse("merge is in progress already");
         this.tag = ~this.tag + 1;
         this.strictNextItem = this.current.first;
         this.removed.grab(this.current, false);
@@ -110,7 +111,7 @@ export class MergeList {
     }
     endMerge(error) {
         if (!this.isMergeInProgress)
-            throw new Error("merge is ended already");
+            throw misuse("merge is ended already");
         this.tag = ~this.tag;
         if (error === undefined) {
             const currentCount = this.current.count;

package/build/dist/source/util/Uri.d.ts

@@ -0,0 +1,20 @@
+export interface UriComponents {
+    scheme: string;
+    authority?: string;
+    path?: string;
+    query?: string;
+    fragment?: string;
+}
+export declare class Uri implements UriComponents {
+    private static readonly regexp;
+    readonly scheme: string;
+    readonly authority: string;
+    readonly path: string;
+    readonly query: string;
+    readonly fragment: string;
+    protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string);
+    equalsTo(uri: Uri): boolean;
+    toString(): string;
+    static parse(value: string): Uri;
+    static from(components: UriComponents): Uri;
+}

package/build/dist/source/util/Uri.js

@@ -0,0 +1,67 @@
+import { misuse } from "./Dbg.js";
+export class Uri {
+    constructor(scheme, authority, path, query, fragment) {
+        this.scheme = scheme;
+        this.authority = authority !== null && authority !== void 0 ? authority : "";
+        this.path = path !== null && path !== void 0 ? path : "";
+        this.query = query !== null && query !== void 0 ? query : "";
+        this.fragment = fragment !== null && fragment !== void 0 ? fragment : "";
+        validateUri(this);
+    }
+    equalsTo(uri) {
+        return this.scheme === uri.scheme &&
+            this.authority === uri.authority &&
+            this.path === uri.path &&
+            this.query === uri.query &&
+            this.fragment === uri.fragment;
+    }
+    toString() {
+        let result = `${this.scheme}://${this.authority}${this.path}`;
+        if (this.query) {
+            result += `?${this.query}`;
+        }
+        if (this.fragment) {
+            result += `#${this.fragment}`;
+        }
+        return result;
+    }
+    static parse(value) {
+        var _a, _b, _c, _d, _e;
+        let result;
+        const match = Uri.regexp.exec(value);
+        if (!match) {
+            result = new Uri("");
+        }
+        else {
+            result = new Uri((_a = match[2]) !== null && _a !== void 0 ? _a : "", (_b = match[4]) !== null && _b !== void 0 ? _b : "", (_c = match[5]) !== null && _c !== void 0 ? _c : "", (_d = match[7]) !== null && _d !== void 0 ? _d : "", (_e = match[9]) !== null && _e !== void 0 ? _e : "");
+        }
+        return result;
+    }
+    static from(components) {
+        return new Uri(components.scheme, components.authority, components.path, components.query, components.fragment);
+    }
+}
+Uri.regexp = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
+const SCHEME_PATTERN = /^\w[\w\d+.-]*$/;
+const SINGLE_SLASH_START = /^\//;
+const DOUBLE_SLASH_START = /^\/\//;
+function validateUri(uri, strict) {
+    if (!uri.scheme && strict) {
+        throw misuse(`Scheme is missing: {scheme: "", authority: "${uri.authority}", path: "${uri.path}", query: "${uri.query}", fragment: "${uri.fragment}"}`);
+    }
+    if (uri.scheme && !SCHEME_PATTERN.test(uri.scheme)) {
+        throw misuse("Scheme contains illegal characters.");
+    }
+    if (uri.path) {
+        if (uri.authority) {
+            if (!SINGLE_SLASH_START.test(uri.path)) {
+                throw misuse("If a URI contains an authority component, then the path component must either be empty or begin with a slash character ('/').");
+            }
+        }
+        else {
+            if (DOUBLE_SLASH_START.test(uri.path)) {
+                throw misuse("If a URI does not contain an authority component, then the path cannot begin with two slash characters ('//').");
+            }
+        }
+    }
+}

package/build/dist/source/util/Utils.js

@@ -7,6 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { fatal, misuse } from "./Dbg.js";
 export class Utils {
     static freezeSet(obj) {
         if (obj instanceof Set) {
@@ -37,7 +38,7 @@ export class Utils {
     }
 }
 export function UNDEF(...args) {
-    throw new Error("this method should never be called");
+    throw fatal(new Error("this method should never be called"));
 }
 export function all(promises) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -63,7 +64,7 @@ export function proceedSyncOrAsync(result, success, failure) {
 }
 export function emitLetters(n) {
     if (n < 0)
-        throw new Error(`emitLetters: argument (${n}) should not be negative or zero`);
+        throw misuse(`emitLetters: argument (${n}) should not be negative or zero`);
     let result = "";
     while (n >= 0) {
         const r = n % 26;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.94.25029",
+  "version": "0.94.25031",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",