vestjs-runtime 0.1.0-dev-ae6b14

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 ealush
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# vestjs-runtime
+
+Internal runtime module used by Vest. This module is not intended to be used directly, but rather used by the `vest` package.

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/vestjs-runtime.development.js

@@ -0,0 +1,388 @@
+'use strict';
+
+var vestUtils = require('vest-utils');
+var context = require('context');
+
+// eslint-disable-next-line
+function walk(startNode, callback, visitOnly) {
+    // If the startNode has no children, there is nothing to walk.
+    if (vestUtils.isNullish(startNode.children)) {
+        return;
+    }
+    let broke = false;
+    // For each child Isolate object, call the callback function.
+    for (const isolate of startNode.children) {
+        if (broke) {
+            return;
+        }
+        // If visitOnly is not provided or the predicate is satisfied, call the callback function.
+        if (vestUtils.isNullish(visitOnly) || vestUtils.optionalFunctionValue(visitOnly, isolate)) {
+            callback(isolate, breakout);
+        }
+        // If the breakout function has been called, stop the walk.
+        if (broke) {
+            return;
+        }
+        // Recursively walk through the child Isolate object.
+        walk(isolate, (child, innerBreakout) => {
+            callback(child, () => {
+                innerBreakout();
+                breakout();
+            });
+        }, visitOnly);
+    }
+    function breakout() {
+        broke = true;
+    }
+}
+// This function returns true if the given predicate function returns true for any Isolate object in the tree.
+// If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+function some(startNode, predicate, visitOnly) {
+    let hasMatch = false;
+    // Call the walk function with a callback function that sets hasMatch to true if the predicate is satisfied.
+    walk(startNode, (node, breakout) => {
+        if (predicate(node)) {
+            breakout();
+            hasMatch = true;
+        }
+    }, visitOnly);
+    return hasMatch;
+}
+// This function returns true if the given predicate function returns true for any Isolate object in the tree.
+// If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+function has(startNode, match) {
+    return some(startNode, () => true, match);
+}
+// This function returns the first Isolate object in the tree that satisfies the given predicate function.
+// If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+function find(startNode, predicate, visitOnly) {
+    let found = null;
+    // Call the walk function with a callback function that sets found to the current node if the predicate is satisfied.
+    walk(startNode, (node, breakout) => {
+        if (predicate(node)) {
+            breakout();
+            found = node;
+        }
+    }, visitOnly);
+    return found;
+}
+// This function returns true if the given predicate function returns true for every Isolate object in the tree.
+// If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+function every(startNode, predicate, visitOnly) {
+    let hasMatch = true;
+    walk(startNode, (node, breakout) => {
+        if (!predicate(node)) {
+            breakout();
+            hasMatch = false;
+        }
+    }, visitOnly);
+    return hasMatch;
+}
+// This function removes all Isolate objects in the tree that
+// satisfy the given predicate function and have a parent.
+// If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+function pluck(startNode, predicate, visitOnly) {
+    walk(startNode, node => {
+        if (predicate(node) && node.parent) {
+            node.parent.removeChild(node);
+        }
+    }, visitOnly);
+}
+// Returns the closest ancestor Isolate object of the given
+//startNode that satisfies the given predicate function.
+function closest(startNode, predicate) {
+    let current = startNode;
+    while (current.parent) {
+        if (predicate(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+// This function returns true if the closest ancestor Isolates of the
+// given startNode that satisfies the given predicate function exists.
+function closestExists(startNode, predicate) {
+    return !!closest(startNode, predicate);
+}
+
+var IsolateWalker = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  closest: closest,
+  closestExists: closestExists,
+  every: every,
+  find: find,
+  has: has,
+  pluck: pluck,
+  some: some,
+  walk: walk
+});
+
+var ErrorStrings;
+(function (ErrorStrings) {
+    ErrorStrings["NO_ACTIVE_ISOLATE"] = "Not within an active isolate";
+    ErrorStrings["ENCOUNTERED_THE_SAME_KEY_TWICE"] = "Encountered the same test key \"{key}\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted.";
+})(ErrorStrings || (ErrorStrings = {}));
+
+const PersistedContext = context.createCascade((stateRef, parentContext) => {
+    if (parentContext) {
+        return null;
+    }
+    vestUtils.invariant(stateRef.historyRoot);
+    const [historyRootNode] = stateRef.historyRoot();
+    const ctxRef = {};
+    vestUtils.assign(ctxRef, {
+        historyNode: historyRootNode,
+        runtimeNode: null,
+        runtimeRoot: null,
+        stateRef,
+    });
+    return ctxRef;
+});
+const Run = PersistedContext.run;
+const RuntimeApi = {
+    Run,
+    createRef,
+    persist,
+    reset,
+    useAvailableRoot,
+    useBus,
+    useCurrentCursor,
+    useEmit,
+    usePrepareEmitter,
+    useXAppData,
+};
+function useBus() {
+    return useX().stateRef.Bus;
+}
+/*
+  Returns an emitter, but it also has a shortcut for emitting an event immediately
+  by passing an event name.
+*/
+function useEmit() {
+    return persist(useBus().emit);
+}
+function usePrepareEmitter(event) {
+    const emit = useEmit();
+    return (arg) => emit(event, arg);
+}
+function useXAppData() {
+    return useX().stateRef.appData;
+}
+function createRef(setter) {
+    return Object.freeze({
+        historyRoot: vestUtils.tinyState.createTinyState(null),
+        Bus: vestUtils.bus.createBus(),
+        appData: vestUtils.optionalFunctionValue(setter),
+    });
+}
+function persist(cb) {
+    const prev = PersistedContext.useX();
+    return ((...args) => {
+        var _a;
+        const ctxToUse = (_a = PersistedContext.use()) !== null && _a !== void 0 ? _a : prev;
+        return PersistedContext.run(ctxToUse.stateRef, () => cb(...args));
+    });
+}
+function useX() {
+    return PersistedContext.useX();
+}
+function useHistoryRoot() {
+    return useX().stateRef.historyRoot();
+}
+function useHistoryNode() {
+    return useX().historyNode;
+}
+function useSetHistory(history) {
+    const [, setHistoryRoot] = useHistoryRoot();
+    setHistoryRoot(history);
+}
+function useHistoryKey(key) {
+    var _a;
+    if (vestUtils.isNullish(key)) {
+        return null;
+    }
+    const historyNode = useX().historyNode;
+    return (_a = historyNode === null || historyNode === void 0 ? void 0 : historyNode.keys[key]) !== null && _a !== void 0 ? _a : null;
+}
+function useIsolate() {
+    var _a;
+    return (_a = useX().runtimeNode) !== null && _a !== void 0 ? _a : null;
+}
+function useCurrentCursor() {
+    var _a, _b;
+    return (_b = (_a = useIsolate()) === null || _a === void 0 ? void 0 : _a.cursor()) !== null && _b !== void 0 ? _b : 0;
+}
+function useRuntimeRoot() {
+    return useX().runtimeRoot;
+}
+function useSetNextIsolateChild(child) {
+    const currentIsolate = useIsolate();
+    vestUtils.invariant(currentIsolate, ErrorStrings.NO_ACTIVE_ISOLATE);
+    currentIsolate.addChild(child);
+}
+function useSetIsolateKey(key, value) {
+    if (!key) {
+        return;
+    }
+    const currentIsolate = useIsolate();
+    vestUtils.invariant(currentIsolate, ErrorStrings.NO_ACTIVE_ISOLATE);
+    if (vestUtils.isNullish(currentIsolate.keys[key])) {
+        currentIsolate.keys[key] = value;
+        return;
+    }
+    vestUtils.deferThrow(vestUtils.text(ErrorStrings.ENCOUNTERED_THE_SAME_KEY_TWICE, { key }));
+}
+function useAvailableRoot() {
+    const root = useRuntimeRoot();
+    if (root) {
+        return root;
+    }
+    const [historyRoot] = useHistoryRoot();
+    return historyRoot;
+}
+function reset() {
+    const [, , resetHistoryRoot] = useHistoryRoot();
+    resetHistoryRoot();
+}
+
+function BaseReconciler(currentNode, historicNode) {
+    if (vestUtils.isNullish(historicNode)) {
+        return currentNode;
+    }
+    return currentNode;
+}
+class Reconciler {
+    static reconcile(reconciler, node, callback) {
+        var _a;
+        const parent = useIsolate();
+        const historyNode = useHistoryNode();
+        let localHistoryNode = historyNode;
+        if (parent) {
+            // If we have a parent, we need to get the history node from the parent's children
+            // We take the history node from the cursor of the active node's children
+            localHistoryNode =
+                (_a = historyNode === null || historyNode === void 0 ? void 0 : historyNode.at(useCurrentCursor())) !== null && _a !== void 0 ? _a : null;
+        }
+        const nextNode = reconciler(node, localHistoryNode);
+        vestUtils.invariant(nextNode);
+        if (Object.is(nextNode, node)) {
+            return [node, useRunAsNew(localHistoryNode, node, callback)];
+        }
+        return [nextNode, nextNode.output];
+    }
+    static removeAllNextNodesInIsolate() {
+        const testIsolate = useIsolate();
+        const historyNode = useHistoryNode();
+        if (!historyNode || !testIsolate) {
+            // This is probably unreachable, but TS is not convinced.
+            // Let's play it safe.
+            return;
+        }
+        historyNode.slice(useCurrentCursor());
+    }
+    static handleIsolateNodeWithKey(node) {
+        vestUtils.invariant(node.usesKey());
+        const prevNodeByKey = useHistoryKey(node.key);
+        let nextNode = node;
+        if (!vestUtils.isNullish(prevNodeByKey)) {
+            nextNode = prevNodeByKey;
+        }
+        useSetIsolateKey(node.key, node);
+        return nextNode;
+    }
+}
+function useRunAsNew(localHistoryNode, current, callback) {
+    const runtimeRoot = useRuntimeRoot();
+    // We're creating a new child isolate context where the local history node
+    // is the current history node, thus advancing the history cursor.
+    const output = Run(Object.assign({ historyNode: localHistoryNode, runtimeNode: current }, (!runtimeRoot && { runtimeRoot: current })), () => callback(current));
+    current.output = output;
+    return output;
+}
+
+class Isolate {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
+    constructor(_data) {
+        this.children = [];
+        this.keys = {};
+        this.parent = null;
+        this.key = null;
+        this.allowReorder = false;
+    }
+    setParent(parent) {
+        this.parent = parent;
+        return this;
+    }
+    saveOutput(output) {
+        this.output = output;
+        return this;
+    }
+    setKey(key) {
+        this.key = key;
+        return this;
+    }
+    usesKey() {
+        return vestUtils.isNotNullish(this.key);
+    }
+    addChild(child) {
+        vestUtils.invariant(this.children);
+        this.children.push(child);
+    }
+    removeChild(node) {
+        var _a, _b;
+        this.children = (_b = (_a = this.children) === null || _a === void 0 ? void 0 : _a.filter(child => child !== node)) !== null && _b !== void 0 ? _b : null;
+    }
+    slice(at) {
+        if (vestUtils.isNullish(this.children)) {
+            return;
+        }
+        this.children.length = at;
+    }
+    at(at) {
+        var _a, _b;
+        return (_b = (_a = this.children) === null || _a === void 0 ? void 0 : _a[at]) !== null && _b !== void 0 ? _b : null;
+    }
+    cursor() {
+        var _a, _b;
+        return (_b = (_a = this.children) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+    }
+    shouldAllowReorder() {
+        var _a;
+        return (_a = closestExists(this, node => node.allowReorder)) !== null && _a !== void 0 ? _a : false;
+    }
+    get rootNode() {
+        var _a;
+        return (_a = closest(this, node => vestUtils.isNullish(node.parent))) !== null && _a !== void 0 ? _a : this;
+    }
+    static create(callback, data) {
+        return this.createImplementation(callback, data);
+    }
+    static createImplementation(callback, data) {
+        const parent = useIsolate();
+        const newCreatedNode = new this(data).setParent(parent);
+        const [nextIsolateChild, output] = Reconciler.reconcile(this.reconciler, newCreatedNode, callback);
+        nextIsolateChild.saveOutput(output);
+        this.setNode(nextIsolateChild);
+        return nextIsolateChild;
+    }
+    static setNode(node) {
+        const parent = useIsolate();
+        if (parent) {
+            useSetNextIsolateChild(node);
+        }
+        else {
+            useSetHistory(node);
+        }
+        node.setParent(parent);
+    }
+    static is(node) {
+        return node instanceof Isolate;
+    }
+}
+Isolate.reconciler = BaseReconciler;
+
+exports.Isolate = Isolate;
+exports.Reconciler = Reconciler;
+exports.VestRuntime = RuntimeApi;
+exports.Walker = IsolateWalker;

package/dist/cjs/vestjs-runtime.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./vestjs-runtime.production.js');
+} else {
+  module.exports = require('./vestjs-runtime.development.js');
+}

package/dist/cjs/vestjs-runtime.production.js

@@ -0,0 +1 @@
+"use strict";var t=require("vest-utils"),e=require("context");function n(e,r,i){if(t.isNullish(e.children))return;let s=!1;for(const o of e.children){if(s)return;if((t.isNullish(i)||t.optionalFunctionValue(i,o))&&r(o,u),s)return;n(o,((t,e)=>{r(t,(()=>{e(),u()}))}),i)}function u(){s=!0}}function r(t,e,r){let i=!1;return n(t,((t,n)=>{e(t)&&(n(),i=!0)}),r),i}function i(t,e){let n=t;for(;n.parent;){if(e(n))return n;n=n.parent}return null}function s(t,e){return!!i(t,e)}var u,o=Object.freeze({__proto__:null,closest:i,closestExists:s,every:function(t,e,r){let i=!0;return n(t,((t,n)=>{e(t)||(n(),i=!1)}),r),i},find:function(t,e,r){let i=null;return n(t,((t,n)=>{e(t)&&(n(),i=t)}),r),i},has:function(t,e){return r(t,(()=>!0),e)},pluck:function(t,e,r){n(t,(t=>{e(t)&&t.parent&&t.parent.removeChild(t)}),r)},some:r,walk:n});!function(t){t.NO_ACTIVE_ISOLATE="Not within an active isolate",t.ENCOUNTERED_THE_SAME_KEY_TWICE='Encountered the same test key "{key}" twice. This may lead to tests overriding each other\'s results, or to tests being unexpectedly omitted.'}(u||(u={}));const l=e.createCascade(((e,n)=>{if(n)return null;t.invariant(e.historyRoot);const[r]=e.historyRoot(),i={};return t.assign(i,{historyNode:r,runtimeNode:null,runtimeRoot:null,stateRef:e}),i})),c=l.run,a={Run:c,createRef:function(e){return Object.freeze({historyRoot:t.tinyState.createTinyState(null),Bus:t.bus.createBus(),appData:t.optionalFunctionValue(e)})},persist:f,reset:function(){const[,,t]=p();t()},useAvailableRoot:function(){const t=R();if(t)return t;const[e]=p();return e},useBus:h,useCurrentCursor:E,useEmit:d,usePrepareEmitter:function(t){const e=d();return n=>e(t,n)},useXAppData:function(){return v().stateRef.appData}};function h(){return v().stateRef.Bus}function d(){return f(h().emit)}function f(t){const e=l.useX();return(...n)=>{var r;const i=null!==(r=l.use())&&void 0!==r?r:e;return l.run(i.stateRef,(()=>t(...n)))}}function v(){return l.useX()}function p(){return v().stateRef.historyRoot()}function N(){return v().historyNode}function y(){var t;return null!==(t=v().runtimeNode)&&void 0!==t?t:null}function E(){var t,e;return null!==(e=null===(t=y())||void 0===t?void 0:t.cursor())&&void 0!==e?e:0}function R(){return v().runtimeRoot}class m{static reconcile(e,n,r){var i;const s=y(),u=N();let o=u;s&&(o=null!==(i=null==u?void 0:u.at(E()))&&void 0!==i?i:null);const l=e(n,o);return t.invariant(l),Object.is(l,n)?[n,_(o,n,r)]:[l,l.output]}static removeAllNextNodesInIsolate(){const t=y(),e=N();e&&t&&e.slice(E())}static handleIsolateNodeWithKey(e){t.invariant(e.usesKey());const n=function(e){var n;if(t.isNullish(e))return null;const r=v().historyNode;return null!==(n=null==r?void 0:r.keys[e])&&void 0!==n?n:null}(e.key);let r=e;return t.isNullish(n)||(r=n),function(e,n){if(!e)return;const r=y();t.invariant(r,u.NO_ACTIVE_ISOLATE),t.isNullish(r.keys[e])?r.keys[e]=n:t.deferThrow(t.text(u.ENCOUNTERED_THE_SAME_KEY_TWICE,{key:e}))}(e.key,e),r}}function _(t,e,n){const r=R(),i=c(Object.assign({historyNode:t,runtimeNode:e},!r&&{runtimeRoot:e}),(()=>n(e)));return e.output=i,i}class k{constructor(t){this.children=[],this.keys={},this.parent=null,this.key=null,this.allowReorder=!1}setParent(t){return this.parent=t,this}saveOutput(t){return this.output=t,this}setKey(t){return this.key=t,this}usesKey(){return t.isNotNullish(this.key)}addChild(e){t.invariant(this.children),this.children.push(e)}removeChild(t){var e,n;this.children=null!==(n=null===(e=this.children)||void 0===e?void 0:e.filter((e=>e!==t)))&&void 0!==n?n:null}slice(e){t.isNullish(this.children)||(this.children.length=e)}at(t){var e,n;return null!==(n=null===(e=this.children)||void 0===e?void 0:e[t])&&void 0!==n?n:null}cursor(){var t,e;return null!==(e=null===(t=this.children)||void 0===t?void 0:t.length)&&void 0!==e?e:0}shouldAllowReorder(){var t;return null!==(t=s(this,(t=>t.allowReorder)))&&void 0!==t&&t}get rootNode(){var e;return null!==(e=i(this,(e=>t.isNullish(e.parent))))&&void 0!==e?e:this}static create(t,e){return this.createImplementation(t,e)}static createImplementation(t,e){const n=y(),r=new this(e).setParent(n),[i,s]=m.reconcile(this.reconciler,r,t);return i.saveOutput(s),this.setNode(i),i}static setNode(e){const n=y();n?function(e){const n=y();t.invariant(n,u.NO_ACTIVE_ISOLATE),n.addChild(e)}(e):function(t){const[,e]=p();e(t)}(e),e.setParent(n)}static is(t){return t instanceof k}}k.reconciler=function(e,n){return t.isNullish(n),e},exports.Isolate=k,exports.Reconciler=m,exports.VestRuntime=a,exports.Walker=o;

package/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}