reactronic 0.94.25030 → 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";

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";

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

@@ -26,6 +26,7 @@ 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 configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
     static get current(): ReactiveTreeNode;
@@ -38,6 +39,7 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     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;
@@ -90,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;
@@ -118,6 +120,7 @@ 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;

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

@@ -17,6 +17,7 @@ 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";
@@ -50,7 +51,7 @@ export class ReactiveTreeNode {
             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;
@@ -62,7 +63,7 @@ export class ReactiveTreeNode {
             }
         }
         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);
         }
@@ -93,11 +94,22 @@ export class ReactiveTreeNode {
     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))
@@ -168,7 +180,7 @@ export class ReactiveTreeVariable {
     }
 }
 export function generateKey(owner) {
-    const n = owner.numerator++;
+    const n = owner !== undefined ? owner.numerator++ : 0;
     const lettered = emitLetters(n);
     let result;
     if (ReactiveSystem.isLogging)
@@ -266,6 +278,16 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
         if (this.has(Mode.autonomous))
             ReactiveTreeNodeImpl.disposableNodeCount++;
     }
+    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;
     }
@@ -283,12 +305,12 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
     }
     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 preparation");
+            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 tryUseTreeVariableValue(variable) {
@@ -302,7 +324,7 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
         var _a;
         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 setTreeVariableValue(variable, value) {
@@ -345,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;
 }

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.25030",
+  "version": "0.94.25031",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",