vestjs-runtime 0.1.0-dev-ae6b14

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

@@ -0,0 +1,391 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vest-utils'), require('context')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vest-utils', 'context'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["vestjs-runtime"] = {}, global["vest-utils"], global.context));
+})(this, (function (exports, vestUtils, context) { 'use strict';
+
+  // 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/umd/vestjs-runtime.production.js

@@ -0,0 +1 @@
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("vest-utils"),require("context")):"function"==typeof define&&define.amd?define(["exports","vest-utils","context"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self)["vestjs-runtime"]={},t["vest-utils"],t.context)}(this,(function(t,e,n){"use strict";function i(t,n,r){if(e.isNullish(t.children))return;let o=!1;for(const u of t.children){if(o)return;if((e.isNullish(r)||e.optionalFunctionValue(r,u))&&n(u,s),o)return;i(u,((t,e)=>{n(t,(()=>{e(),s()}))}),r)}function s(){o=!0}}function r(t,e,n){let r=!1;return i(t,((t,n)=>{e(t)&&(n(),r=!0)}),n),r}function o(t,e){let n=t;for(;n.parent;){if(e(n))return n;n=n.parent}return null}function s(t,e){return!!o(t,e)}var u,l=Object.freeze({__proto__:null,closest:o,closestExists:s,every:function(t,e,n){let r=!0;return i(t,((t,n)=>{e(t)||(n(),r=!1)}),n),r},find:function(t,e,n){let r=null;return i(t,((t,n)=>{e(t)&&(n(),r=t)}),n),r},has:function(t,e){return r(t,(()=>!0),e)},pluck:function(t,e,n){i(t,(t=>{e(t)&&t.parent&&t.parent.removeChild(t)}),n)},some:r,walk:i});!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 c=n.createCascade(((t,n)=>{if(n)return null;e.invariant(t.historyRoot);const[i]=t.historyRoot(),r={};return e.assign(r,{historyNode:i,runtimeNode:null,runtimeRoot:null,stateRef:t}),r})),a=c.run,h={Run:a,createRef:function(t){return Object.freeze({historyRoot:e.tinyState.createTinyState(null),Bus:e.bus.createBus(),appData:e.optionalFunctionValue(t)})},persist:v,reset:function(){const[,,t]=y();t()},useAvailableRoot:function(){const t=R();if(t)return t;const[e]=y();return e},useBus:d,useCurrentCursor:E,useEmit:f,usePrepareEmitter:function(t){const e=f();return n=>e(t,n)},useXAppData:function(){return p().stateRef.appData}};function d(){return p().stateRef.Bus}function f(){return v(d().emit)}function v(t){const e=c.useX();return(...n)=>{var i;const r=null!==(i=c.use())&&void 0!==i?i:e;return c.run(r.stateRef,(()=>t(...n)))}}function p(){return c.useX()}function y(){return p().stateRef.historyRoot()}function N(){return p().historyNode}function m(){var t;return null!==(t=p().runtimeNode)&&void 0!==t?t:null}function E(){var t,e;return null!==(e=null===(t=m())||void 0===t?void 0:t.cursor())&&void 0!==e?e:0}function R(){return p().runtimeRoot}class _{static reconcile(t,n,i){var r;const o=m(),s=N();let u=s;o&&(u=null!==(r=null==s?void 0:s.at(E()))&&void 0!==r?r:null);const l=t(n,u);return e.invariant(l),Object.is(l,n)?[n,T(u,n,i)]:[l,l.output]}static removeAllNextNodesInIsolate(){const t=m(),e=N();e&&t&&e.slice(E())}static handleIsolateNodeWithKey(t){e.invariant(t.usesKey());const n=function(t){var n;if(e.isNullish(t))return null;const i=p().historyNode;return null!==(n=null==i?void 0:i.keys[t])&&void 0!==n?n:null}(t.key);let i=t;return e.isNullish(n)||(i=n),function(t,n){if(!t)return;const i=m();e.invariant(i,u.NO_ACTIVE_ISOLATE),e.isNullish(i.keys[t])?i.keys[t]=n:e.deferThrow(e.text(u.ENCOUNTERED_THE_SAME_KEY_TWICE,{key:t}))}(t.key,t),i}}function T(t,e,n){const i=R(),r=a(Object.assign({historyNode:t,runtimeNode:e},!i&&{runtimeRoot:e}),(()=>n(e)));return e.output=r,r}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 e.isNotNullish(this.key)}addChild(t){e.invariant(this.children),this.children.push(t)}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(t){e.isNullish(this.children)||(this.children.length=t)}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 t;return null!==(t=o(this,(t=>e.isNullish(t.parent))))&&void 0!==t?t:this}static create(t,e){return this.createImplementation(t,e)}static createImplementation(t,e){const n=m(),i=new this(e).setParent(n),[r,o]=_.reconcile(this.reconciler,i,t);return r.saveOutput(o),this.setNode(r),r}static setNode(t){const n=m();n?function(t){const n=m();e.invariant(n,u.NO_ACTIVE_ISOLATE),n.addChild(t)}(t):function(t){const[,e]=y();e(t)}(t),t.setParent(n)}static is(t){return t instanceof k}}k.reconciler=function(t,n){return e.isNullish(n),t},t.Isolate=k,t.Reconciler=_,t.VestRuntime=h,t.Walker=l}));

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "vestjs-runtime",
+  "version": "0.1.0-dev-ae6b14",
+  "description": "Internal runtime module used by Vest",
+  "license": "MIT",
+  "author": "ealush",
+  "main": "./dist/cjs/vestjs-runtime.js",
+  "module": "./dist/es/vestjs-runtime.production.js",
+  "unpkg": "./dist/umd/vestjs-runtime.production.js",
+  "jsdelivr": "./dist/umd/vestjs-runtime.production.js",
+  "types": "./types/vestjs-runtime.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ealush/vest.git",
+    "directory": "packages/vestjs-runtime"
+  },
+  "bugs": {
+    "url": "https://github.com/ealush/vest.git/issues"
+  },
+  "dependencies": {
+    "context": "3.0.9-dev-ae6b14",
+    "vest-utils": "1.0.0-dev-ae6b14"
+  },
+  "exports": {
+    ".": {
+      "development": {
+        "types": "./types/vestjs-runtime.d.ts",
+        "browser": "./dist/es/vestjs-runtime.development.js",
+        "umd": "./dist/umd/vestjs-runtime.development.js",
+        "import": "./dist/es/vestjs-runtime.development.js",
+        "require": "./dist/cjs/vestjs-runtime.development.js",
+        "node": "./dist/cjs/vestjs-runtime.development.js",
+        "module": "./dist/es/vestjs-runtime.development.js",
+        "default": "./dist/cjs/vestjs-runtime.development.js"
+      },
+      "types": "./types/vestjs-runtime.d.ts",
+      "browser": "./dist/es/vestjs-runtime.production.js",
+      "umd": "./dist/umd/vestjs-runtime.production.js",
+      "import": "./dist/es/vestjs-runtime.production.js",
+      "require": "./dist/cjs/vestjs-runtime.production.js",
+      "node": "./dist/cjs/vestjs-runtime.production.js",
+      "module": "./dist/es/vestjs-runtime.production.js",
+      "default": "./dist/cjs/vestjs-runtime.production.js"
+    },
+    "./package.json": "./package.json",
+    "./*": "./*"
+  }
+}

package/types/vestjs-runtime.d.ts

@@ -0,0 +1,143 @@
+import { CB, TinyState, BusType } from "vest-utils";
+interface IRecociler {
+    (currentNode: Isolate, historicNode: Isolate | null): Isolate;
+}
+declare class Reconciler {
+    static reconcile<Callback extends CB = CB>(reconciler: IRecociler, node: Isolate, callback: Callback): [
+        Isolate,
+        ReturnType<Callback>
+    ];
+    static removeAllNextNodesInIsolate(): void;
+    static handleIsolateNodeWithKey(node: Isolate): Isolate;
+}
+type IsolateKey = null | string;
+declare class Isolate<_D = any> {
+    children: Isolate[] | null;
+    keys: Record<string, Isolate>;
+    parent: Isolate | null;
+    output?: any;
+    key: IsolateKey;
+    allowReorder: boolean;
+    static reconciler: IRecociler;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
+    constructor(_data?: _D);
+    setParent(parent: Isolate | null): this;
+    saveOutput(output: any): this;
+    setKey(key: string | null): this;
+    usesKey(): boolean;
+    addChild(child: Isolate): void;
+    removeChild(node: Isolate): void;
+    slice(at: number): void;
+    at(at: number): Isolate | null;
+    cursor(): number;
+    shouldAllowReorder(): boolean;
+    get rootNode(): Isolate;
+    static create<Callback extends CB = CB>(callback: Callback, data?: any): Isolate;
+    private static createImplementation;
+    static setNode(node: Isolate): void;
+    static is(node: any): boolean;
+}
+declare namespace Walker {
+    interface IRecociler {
+        (currentNode: Isolate, historicNode: Isolate | null): Isolate;
+    }
+    function BaseReconciler(currentNode: Isolate, historicNode: Isolate | null): Isolate;
+    class Reconciler {
+        static reconcile<Callback extends CB = CB>(reconciler: IRecociler, node: Isolate, callback: Callback): [
+            Isolate,
+            ReturnType<Callback>
+        ];
+        static removeAllNextNodesInIsolate(): void;
+        static handleIsolateNodeWithKey(node: Isolate): Isolate;
+    }
+    type IsolateKey = null | string;
+    class Isolate<_D = any> {
+        children: Isolate[] | null;
+        keys: Record<string, Isolate>;
+        parent: Isolate | null;
+        output?: any;
+        key: IsolateKey;
+        allowReorder: boolean;
+        static reconciler: IRecociler;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
+        constructor(_data?: _D);
+        setParent(parent: Isolate | null): this;
+        saveOutput(output: any): this;
+        setKey(key: string | null): this;
+        usesKey(): boolean;
+        addChild(child: Isolate): void;
+        removeChild(node: Isolate): void;
+        slice(at: number): void;
+        at(at: number): Isolate | null;
+        cursor(): number;
+        shouldAllowReorder(): boolean;
+        get rootNode(): Isolate;
+        static create<Callback extends CB = CB>(callback: Callback, data?: any): Isolate;
+        private static createImplementation;
+        static setNode(node: Isolate): void;
+        static is(node: any): boolean;
+    }
+    type VisitOnlyPredicate = (isolate: Isolate) => boolean;
+    // eslint-disable-next-line
+    function walk(startNode: Isolate, callback: (isolate: Isolate, breakout: () => void) => void, visitOnly?: VisitOnlyPredicate): void;
+    // 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: Isolate, predicate: (node: Isolate) => boolean, visitOnly?: VisitOnlyPredicate): boolean;
+    // 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: Isolate, match: VisitOnlyPredicate): boolean;
+    // 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: Isolate, predicate: (node: Isolate) => boolean, visitOnly?: VisitOnlyPredicate): Isolate | null;
+    // 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: Isolate, predicate: (node: Isolate) => boolean, visitOnly?: VisitOnlyPredicate): boolean;
+    // 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: Isolate, predicate: (node: Isolate) => boolean, visitOnly?: VisitOnlyPredicate): void;
+    // Returns the closest ancestor Isolate object of the given
+    //startNode that satisfies the given predicate function.
+    function closest(startNode: Isolate, predicate: (node: Isolate) => boolean): Isolate | null;
+    // This function returns true if the closest ancestor Isolates of the
+    // given startNode that satisfies the given predicate function exists.
+    function closestExists(startNode: Isolate, predicate: (node: Isolate) => boolean): boolean;
+}
+type CTXType = StateRefType & {
+    historyNode: Isolate | null;
+    runtimeNode: Isolate | null;
+    runtimeRoot: Isolate | null;
+    stateRef: StateRefType;
+};
+type StateRefType = {
+    historyRoot: TinyState<Isolate | null>;
+    Bus: BusType;
+    appData: Record<string, any>;
+};
+declare const RuntimeApi: {
+    Run: <R>(value: Partial<CTXType>, fn: () => R) => R;
+    createRef: typeof createRef;
+    persist: typeof persist;
+    reset: typeof reset;
+    useAvailableRoot: typeof useAvailableRoot;
+    useBus: typeof useBus;
+    useCurrentCursor: typeof useCurrentCursor;
+    useEmit: typeof useEmit;
+    usePrepareEmitter: typeof usePrepareEmitter;
+    useXAppData: typeof useXAppData;
+};
+declare function useBus(): BusType;
+/*
+Returns an emitter, but it also has a shortcut for emitting an event immediately
+by passing an event name.
+*/
+declare function useEmit(): (event: string, ...args: any[]) => void;
+declare function usePrepareEmitter<T = void>(event: string): (arg: T) => void;
+declare function useXAppData<T = object>(): T;
+declare function createRef(setter: Record<string, any> | (() => Record<string, any>)): StateRefType;
+declare function persist<T extends CB>(cb: T): T;
+declare function useCurrentCursor(): number;
+declare function useAvailableRoot<I extends Isolate = Isolate>(): I;
+declare function reset(): void;
+export { Isolate, IsolateKey, Reconciler, IRecociler, Walker, RuntimeApi as VestRuntime };
+//# sourceMappingURL=vestjs-runtime.d.ts.map

package/types/vestjs-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vestjs-runtime.d.ts","sourceRoot":"","sources":["../src/vestjs-runtime.ts","../src/IsolateWalker.ts","../src/errors/ErrorStrings.ts","../src/VestRuntime.ts","../src/Reconciler.ts","../src/Isolate.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,kFAAuB,CAAgB"}