reactronic 0.94.25030 → 0.94.25032

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/Enums.d.ts

@@ -1,8 +1,7 @@
 export declare enum Mode {
     default = 0,
     autonomous = 1,
-    manualMount = 2,
-    rootNode = 4
+    external = 2
 }
 export declare enum Priority {
     realtime = 0,

package/build/dist/source/Enums.js

@@ -2,8 +2,7 @@ export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
     Mode[Mode["autonomous"] = 1] = "autonomous";
-    Mode[Mode["manualMount"] = 2] = "manualMount";
-    Mode[Mode["rootNode"] = 4] = "rootNode";
+    Mode[Mode["external"] = 2] = "external";
 })(Mode || (Mode = {}));
 export var Priority;
 (function (Priority) {

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 { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
+export { launch, 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 { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
+export { launch, 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,6 +6,7 @@ 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 function launch<T>(node: ReactiveTreeNode<T>, triggers?: unknown): ReactiveTreeNode<T>;
 export declare abstract class ReactiveTreeNode<E = unknown> {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
@@ -26,6 +27,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;
@@ -34,10 +36,11 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     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 launchScript(node: ReactiveTreeNode<any>, triggers: unknown): void;
+    static launchFinalization(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 +93,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 +121,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,12 +17,17 @@ 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 { emitLetters, flags, 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 function launch(node, triggers) {
+    ReactiveTreeNode.launchScript(node, triggers);
+    return node;
+}
 export class ReactiveTreeNode {
     static get current() {
         return ReactiveTreeNodeImpl.nodeSlot.instance;
@@ -42,7 +47,7 @@ export class ReactiveTreeNode {
         else
             declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
         let effectiveKey = declaration.key;
-        const owner = (getModeUsingBasisChain(declaration) & Mode.rootNode) !== Mode.rootNode ? gNodeSlot === null || gNodeSlot === void 0 ? void 0 : gNodeSlot.instance : undefined;
+        const owner = gNodeSlot === null || gNodeSlot === void 0 ? void 0 : gNodeSlot.instance;
         if (owner) {
             let existing = owner.driver.declareChild(owner, driver, declaration, declaration.basis);
             const children = owner.children;
@@ -50,7 +55,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,9 +67,8 @@ 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);
         }
         return result;
     }
@@ -75,17 +79,17 @@ export class ReactiveTreeNode {
             declaration = basis !== null && basis !== void 0 ? basis : {};
         return declaration;
     }
-    static triggerScriptRun(node, triggers) {
+    static launchScript(node, triggers) {
         const impl = node;
         const declaration = impl.declaration;
-        if (!observablesAreEqual(triggers, declaration.triggers)) {
+        if (node.stamp >= Number.MAX_SAFE_INTEGER || !observablesAreEqual(triggers, declaration.triggers)) {
             declaration.triggers = triggers;
-            triggerScriptRunViaSlot(impl.slot);
+            launchScriptViaSlot(impl.slot);
         }
     }
-    static triggerFinalization(node) {
+    static launchFinalization(node) {
         const impl = node;
-        triggerFinalization(impl.slot, true, true);
+        launchFinalization(impl.slot, true, true);
     }
     static runNestedNodeScriptsThenDo(action) {
         runNestedNodeScriptsThenDoImpl(ReactiveTreeNodeImpl.nodeSlot, undefined, action);
@@ -93,11 +97,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 +183,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 +281,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;
     }
@@ -276,19 +301,19 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
         return this.owner.children.isMoved(this.slot);
     }
     has(mode) {
-        return (getModeUsingBasisChain(this.declaration) & mode) === mode;
+        return flags(getModeUsingBasisChain(this.declaration), mode);
     }
     script(_triggers) {
         runScriptNow(this.slot);
     }
     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 +327,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 +370,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;
 }
@@ -358,7 +393,7 @@ function runNestedNodeScriptsThenDoImpl(nodeSlot, error, action) {
             try {
                 children.endMerge(error);
                 for (const child of children.removedItems(true))
-                    triggerFinalization(child, true, true);
+                    launchFinalization(child, true, true);
                 if (!error) {
                     const sequential = children.isStrict;
                     let p1 = undefined;
@@ -374,7 +409,7 @@ function runNestedNodeScriptsThenDoImpl(nodeSlot, error, action) {
                         mounting = markToMountIfNecessary(mounting, host, child, children, sequential);
                         const p = (_a = childNode.priority) !== null && _a !== void 0 ? _a : Priority.realtime;
                         if (p === Priority.realtime)
-                            triggerScriptRunViaSlot(child);
+                            launchScriptViaSlot(child);
                         else if (p === Priority.normal)
                             p1 = push(child, p1);
                         else
@@ -395,7 +430,7 @@ function runNestedNodeScriptsThenDoImpl(nodeSlot, error, action) {
 }
 function markToMountIfNecessary(mounting, host, nodeSlot, children, sequential) {
     const node = nodeSlot.instance;
-    if (node.element.native && !node.has(Mode.manualMount)) {
+    if (node.element.native && !node.has(Mode.external)) {
         if (mounting || node.host !== host) {
             children.markAsMoved(nodeSlot);
             mounting = false;
@@ -428,7 +463,7 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
                 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);
+                    launchScriptViaSlot(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
                         ReactiveTreeNodeImpl.currentScriptPriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
@@ -446,7 +481,7 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
         }
     });
 }
-function triggerScriptRunViaSlot(nodeSlot) {
+function launchScriptViaSlot(nodeSlot) {
     const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         if (node.has(Mode.autonomous)) {
@@ -473,14 +508,14 @@ function mountOrRemountIfNecessary(node) {
         runNonReactively(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
             driver.runPreparation(node);
-            if (!node.has(Mode.manualMount)) {
+            if (!node.has(Mode.external)) {
                 node.stamp = 0;
                 if (node.host !== node)
                     driver.runMount(node);
             }
         });
     }
-    else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
+    else if (node.isMoved && !node.has(Mode.external) && node.host !== node)
         runNonReactively(() => driver.runMount(node));
 }
 function runScriptNow(nodeSlot) {
@@ -507,7 +542,7 @@ function runScriptNow(nodeSlot) {
         });
     }
 }
-function triggerFinalization(nodeSlot, isLeader, individual) {
+function launchFinalization(nodeSlot, isLeader, individual) {
     const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         const driver = node.driver;
@@ -528,7 +563,7 @@ function triggerFinalization(nodeSlot, isLeader, individual) {
                 });
         }
         for (const child of node.children.items())
-            triggerFinalization(child, childrenAreLeaders, false);
+            launchFinalization(child, childrenAreLeaders, false);
         ReactiveTreeNodeImpl.grandNodeCount--;
     }
 }

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.d.ts

@@ -4,6 +4,7 @@ export declare class Utils {
     static freezeMap<K, V>(obj?: Map<K, V>): Map<K, V> | undefined;
     static copyAllMembers(source: any, target: any): any;
 }
+export declare function flags(value: number, flags: number): boolean;
 export declare function UNDEF(...args: any[]): never;
 export declare function all(promises: Array<Promise<any>>): Promise<any[]>;
 export declare function pause<T>(timeout: number): Promise<T>;

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) {
@@ -36,8 +37,11 @@ export class Utils {
         return target;
     }
 }
+export function flags(value, flags) {
+    return (value & flags) === flags;
+}
 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 +67,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.25032",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",