vast 2.0.0 → 2.0.2

package/CHANGELOG.md

@@ -5,32 +5,8 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## 2.0.0 - 2021-12-24
-### Changed or removed
-- e8652bc  breaking(vest, enforce): prepare next major (ealush)
 
-### Fixed and improved
-- 825e74b  types(n4s): fix proxy type (ealush)
-- 9f9b970  vx: improve package.json generation (ealush)
-- 7baedf2  n4s: use named export in entry (ealush)
-- e60e9a6  vx: make exports of a module use its main entry as an external (ealush)
-- 94e00a8  patch(vest): Add isolate module for containing re-orders (ealush)
-- bed7040  vx: add back to workspace (ealush)
-- a87824b  vx: add types to exports (ealush)
-- f2d458d  update build artifacts (ealush)
-- package.json
-- packages/anyone/package.json
-- .eslintrc.js
-- packages/anyone/package.json
-- eeac20e  chore: remove duplicate types (undefined)
-- packages/anyone/package.json
-- 4d88c04  patch: add nodejs exports (undefined)
-- packages/anyone/package.json
-- 26af06b  chore: reduce complexity, remove all lint errors (undefined)
-- packages/anyone/.npmignore
-- .github/PULL_REQUEST_TEMPLATE.md
-- ba68539  lint: handling lint of all packages (ealush)
-- .gitignore
-- 73b28a1  chore: some lint fixes (ealush)
+- Use named exports
 
 ## 1.0.11 - 2021-07-02
 

package/README.md

@@ -1,12 +1,14 @@
 # Vast - Simple State Utility for Libraries
 
-Vast is a simple state utility created to use in [Vest](https://github.com/ealush/vest). It allows using a similar pattern to React's useState hook to store data.
+Vast is a tiny state container inspired by React's `useState`, designed for libraries that need predictable, reusable state without a UI framework.
 
-Note that this is mostly intended to be used within libraries, and not as a consumer facing interface. When paired with a context propagation libraries such as [context](https://github.com/ealush/context), it can have pretty powerful capabilities. See Vest for a real life example.
+- Register any number of state keys, each with its own getter/setter pair.
+- Provide global `onStateChange` and per-key `onUpdate` callbacks to react to changes.
+- Reset state back to initial values at any time.
 
 ## Installation
 
-```
+```bash
 npm i vast
 ```
 
@@ -15,51 +17,48 @@ npm i vast
 ```js
 import { createState } from 'vast';
 
-const state = createState(); // Creates a state reference.
+// Optional callback runs on every state change
+const state = createState(() => console.log('state changed'));
 
-const useColor = state.registerStateKey('blue'); // Creates a new key in the state, and gives it an initial value
-// You can also pass in a function to use as the initial state
+// Create a key with an initial value
+const useColor = state.registerStateKey('blue');
 
-const [color, setColor] = useColor(); // ["blue", Function]
-setColor('red'); // set the color to "red"
-```
+const [color, setColor] = useColor();
+setColor('red');
 
-The next time you will call `useColor` the value of `color` will be `"red"`.
+// Next call returns the updated value
+const [current] = useColor();
+// current === 'red'
+```
 
-You can also set a computed value by passing in a function:
+The setter accepts either a value or an updater function that receives the current state value:
 
 ```js
-const [color, setColor] = useColor(); // ["blue", Function]
-setColor(currentColor => (color === 'red' ? 'blue' : 'red'));
+const [count, setCount] = state.registerStateKey(0)();
+setCount(prev => prev + 1);
 ```
 
-## Subscribing to changes
-
-### Getting notified for every change in the state
+## Subscriptions
 
-**NOTE** This will not let you know what change was made, but only that a key in the state was updated or added:
-
-Simply add an onChange callback to your createState:
+- `onStateChange` (passed to `createState`) fires after every update to any key.
+- `onUpdate` (passed to `registerStateKey`) fires for that key when it initializes and whenever it changes, receiving `(current, previous)`.
 
 ```js
-const state = createState(() => console.log('the state was updated!'));
-```
+const logColorChange = (next, prev) => console.log(`color: ${prev} -> ${next}`);
+const useColor = state.registerStateKey('blue', logColorChange);
 
-Now on every state change, this callback will run.
+useColor()[1]('green');
+// logs: color: blue -> green
+```
 
-Alternatively, if you need more granularity, you can subscribe to specific state keys.
+`onUpdate` is invoked before the global `onStateChange`, matching the library's execution order.
 
-### Subscribing to specific state key updates
+## Resetting state
 
-If you need to react to specific changes in your state, you can add an `onUpdate` callback to those state key registrations:
+Call `state.reset()` to restore every registered key to its initial value. Setters still work after a reset:
 
 ```js
-const useColor = state.registerStateKey(
-  'red',
-  (currentState, previousState) => {
-    console.log(`the color changed from ${previousState} to ${currentState}!`);
-  }
-);
+state.reset();
+const [color, setColor] = useColor();
+setColor('purple');
 ```
-
-Now, whenever a state update happens in that key, your callback will run, providing the previous and changed value as well.

package/dist/vast.cjs

@@ -0,0 +1,55 @@
+let vest_utils = require("vest-utils");
+
+//#region src/vast.ts
+function createState(onStateChange) {
+	const state = { references: [] };
+	const registrations = [];
+	return {
+		registerStateKey,
+		reset
+	};
+	/**
+	* Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
+	*
+	* @example
+	*
+	* const useColor = state.registerStateKey("blue");
+	*
+	* let [color, setColor] = useColor(); // -> ["blue", Function]
+	*
+	* setColor("green");
+	*
+	* useColor()[0]; -> "green"
+	*/
+	function registerStateKey(initialState, onUpdate) {
+		const key = registrations.length;
+		registrations.push([initialState, onUpdate]);
+		return initKey(key, initialState);
+	}
+	function reset() {
+		const prev = current();
+		state.references = [];
+		registrations.forEach(([initialValue], index) => initKey(index, initialValue, prev[index]));
+	}
+	function initKey(key, initialState, prevState) {
+		current().push();
+		set(key, (0, vest_utils.dynamicValue)(initialState, prevState));
+		return function useStateKey() {
+			return [current()[key], (nextState) => set(key, (0, vest_utils.dynamicValue)(nextState, current()[key]))];
+		};
+	}
+	function current() {
+		return state.references;
+	}
+	function set(index, value) {
+		const prevValue = state.references[index];
+		state.references[index] = value;
+		const [, onUpdate] = registrations[index];
+		if ((0, vest_utils.isFunction)(onUpdate)) onUpdate(value, prevValue);
+		if ((0, vest_utils.isFunction)(onStateChange)) onStateChange();
+	}
+}
+
+//#endregion
+exports.createState = createState;
+//# sourceMappingURL=vast.cjs.map

package/dist/vast.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vast.cjs","names":["state: {\n    references: unknown[];\n  }","registrations: [\n    unknown,\n    (<S>(currentState: S, prevState: S) => void)?,\n  ][]"],"sources":["../src/vast.ts"],"sourcesContent":["import { CB, DynamicValue, Maybe, isFunction, dynamicValue } from 'vest-utils';\n\n// eslint-disable-next-line max-lines-per-function\nexport function createState(\n  onStateChange?: (...args: unknown[]) => unknown,\n): CreateStateReturn {\n  const state: {\n    references: unknown[];\n  } = {\n    references: [],\n  };\n\n  const registrations: [\n    unknown,\n    (<S>(currentState: S, prevState: S) => void)?,\n  ][] = [];\n\n  return {\n    registerStateKey,\n    reset,\n  };\n\n  /**\n   * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.\n   *\n   * @example\n   *\n   * const useColor = state.registerStateKey(\"blue\");\n   *\n   * let [color, setColor] = useColor(); // -> [\"blue\", Function]\n   *\n   * setColor(\"green\");\n   *\n   * useColor()[0]; -> \"green\"\n   */\n  function registerStateKey<S>(\n    initialState?: Maybe<StateInput<S>>,\n    onUpdate?: () => void,\n  ): CB<StateHandlerReturn<S>> {\n    const key = registrations.length;\n    registrations.push([initialState, onUpdate]);\n    return initKey(key, initialState);\n  }\n\n  function reset(): void {\n    const prev = current();\n    state.references = [];\n    registrations.forEach(([initialValue], index) =>\n      initKey(index, initialValue, prev[index]),\n    );\n  }\n\n  function initKey<S>(\n    key: number,\n    initialState?: Maybe<StateInput<S>>,\n    prevState?: Maybe<S>,\n  ) {\n    current().push();\n    set(key, dynamicValue(initialState, prevState));\n\n    return function useStateKey(): StateHandlerReturn<S> {\n      return [\n        current()[key],\n        (nextState: SetStateInput<S>) =>\n          set(key, dynamicValue(nextState, current()[key])),\n      ];\n    };\n  }\n\n  function current(): any[] {\n    return state.references;\n  }\n\n  function set(index: number, value: unknown): void {\n    const prevValue = state.references[index];\n    state.references[index] = value;\n\n    const [, onUpdate] = registrations[index];\n\n    if (isFunction(onUpdate)) {\n      onUpdate(value, prevValue);\n    }\n\n    if (isFunction(onStateChange)) {\n      onStateChange();\n    }\n  }\n}\n\ntype StateInput<S> = DynamicValue<S, [prevState?: S]>;\ntype SetStateInput<S> = DynamicValue<S, [prevState: S]>;\n\nexport type State = CreateStateReturn;\nexport type StateHandlerReturn<S> = [S, (nextState: SetStateInput<S>) => void];\nexport type UseState<S> = CB<StateHandlerReturn<S>>;\n\ntype CreateStateReturn = {\n  reset: () => void;\n  registerStateKey: <S>(\n    initialState?: Maybe<StateInput<S>>,\n    onUpdate?: () => void,\n  ) => CB<StateHandlerReturn<S>>;\n};\n"],"mappings":";;;AAGA,SAAgB,YACd,eACmB;CACnB,MAAMA,QAEF,EACF,YAAY,EAAE,EACf;CAED,MAAMC,gBAGA,EAAE;AAER,QAAO;EACL;EACA;EACD;;;;;;;;;;;;;;CAeD,SAAS,iBACP,cACA,UAC2B;EAC3B,MAAM,MAAM,cAAc;AAC1B,gBAAc,KAAK,CAAC,cAAc,SAAS,CAAC;AAC5C,SAAO,QAAQ,KAAK,aAAa;;CAGnC,SAAS,QAAc;EACrB,MAAM,OAAO,SAAS;AACtB,QAAM,aAAa,EAAE;AACrB,gBAAc,SAAS,CAAC,eAAe,UACrC,QAAQ,OAAO,cAAc,KAAK,OAAO,CAC1C;;CAGH,SAAS,QACP,KACA,cACA,WACA;AACA,WAAS,CAAC,MAAM;AAChB,MAAI,kCAAkB,cAAc,UAAU,CAAC;AAE/C,SAAO,SAAS,cAAqC;AACnD,UAAO,CACL,SAAS,CAAC,OACT,cACC,IAAI,kCAAkB,WAAW,SAAS,CAAC,KAAK,CAAC,CACpD;;;CAIL,SAAS,UAAiB;AACxB,SAAO,MAAM;;CAGf,SAAS,IAAI,OAAe,OAAsB;EAChD,MAAM,YAAY,MAAM,WAAW;AACnC,QAAM,WAAW,SAAS;EAE1B,MAAM,GAAG,YAAY,cAAc;AAEnC,iCAAe,SAAS,CACtB,UAAS,OAAO,UAAU;AAG5B,iCAAe,cAAc,CAC3B,gBAAe"}

package/dist/vast.mjs

@@ -0,0 +1,55 @@
+import { dynamicValue, isFunction } from "vest-utils";
+
+//#region src/vast.ts
+function createState(onStateChange) {
+	const state = { references: [] };
+	const registrations = [];
+	return {
+		registerStateKey,
+		reset
+	};
+	/**
+	* Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
+	*
+	* @example
+	*
+	* const useColor = state.registerStateKey("blue");
+	*
+	* let [color, setColor] = useColor(); // -> ["blue", Function]
+	*
+	* setColor("green");
+	*
+	* useColor()[0]; -> "green"
+	*/
+	function registerStateKey(initialState, onUpdate) {
+		const key = registrations.length;
+		registrations.push([initialState, onUpdate]);
+		return initKey(key, initialState);
+	}
+	function reset() {
+		const prev = current();
+		state.references = [];
+		registrations.forEach(([initialValue], index) => initKey(index, initialValue, prev[index]));
+	}
+	function initKey(key, initialState, prevState) {
+		current().push();
+		set(key, dynamicValue(initialState, prevState));
+		return function useStateKey() {
+			return [current()[key], (nextState) => set(key, dynamicValue(nextState, current()[key]))];
+		};
+	}
+	function current() {
+		return state.references;
+	}
+	function set(index, value) {
+		const prevValue = state.references[index];
+		state.references[index] = value;
+		const [, onUpdate] = registrations[index];
+		if (isFunction(onUpdate)) onUpdate(value, prevValue);
+		if (isFunction(onStateChange)) onStateChange();
+	}
+}
+
+//#endregion
+export { createState };
+//# sourceMappingURL=vast.mjs.map

package/dist/vast.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vast.mjs","names":["state: {\n    references: unknown[];\n  }","registrations: [\n    unknown,\n    (<S>(currentState: S, prevState: S) => void)?,\n  ][]"],"sources":["../src/vast.ts"],"sourcesContent":["import { CB, DynamicValue, Maybe, isFunction, dynamicValue } from 'vest-utils';\n\n// eslint-disable-next-line max-lines-per-function\nexport function createState(\n  onStateChange?: (...args: unknown[]) => unknown,\n): CreateStateReturn {\n  const state: {\n    references: unknown[];\n  } = {\n    references: [],\n  };\n\n  const registrations: [\n    unknown,\n    (<S>(currentState: S, prevState: S) => void)?,\n  ][] = [];\n\n  return {\n    registerStateKey,\n    reset,\n  };\n\n  /**\n   * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.\n   *\n   * @example\n   *\n   * const useColor = state.registerStateKey(\"blue\");\n   *\n   * let [color, setColor] = useColor(); // -> [\"blue\", Function]\n   *\n   * setColor(\"green\");\n   *\n   * useColor()[0]; -> \"green\"\n   */\n  function registerStateKey<S>(\n    initialState?: Maybe<StateInput<S>>,\n    onUpdate?: () => void,\n  ): CB<StateHandlerReturn<S>> {\n    const key = registrations.length;\n    registrations.push([initialState, onUpdate]);\n    return initKey(key, initialState);\n  }\n\n  function reset(): void {\n    const prev = current();\n    state.references = [];\n    registrations.forEach(([initialValue], index) =>\n      initKey(index, initialValue, prev[index]),\n    );\n  }\n\n  function initKey<S>(\n    key: number,\n    initialState?: Maybe<StateInput<S>>,\n    prevState?: Maybe<S>,\n  ) {\n    current().push();\n    set(key, dynamicValue(initialState, prevState));\n\n    return function useStateKey(): StateHandlerReturn<S> {\n      return [\n        current()[key],\n        (nextState: SetStateInput<S>) =>\n          set(key, dynamicValue(nextState, current()[key])),\n      ];\n    };\n  }\n\n  function current(): any[] {\n    return state.references;\n  }\n\n  function set(index: number, value: unknown): void {\n    const prevValue = state.references[index];\n    state.references[index] = value;\n\n    const [, onUpdate] = registrations[index];\n\n    if (isFunction(onUpdate)) {\n      onUpdate(value, prevValue);\n    }\n\n    if (isFunction(onStateChange)) {\n      onStateChange();\n    }\n  }\n}\n\ntype StateInput<S> = DynamicValue<S, [prevState?: S]>;\ntype SetStateInput<S> = DynamicValue<S, [prevState: S]>;\n\nexport type State = CreateStateReturn;\nexport type StateHandlerReturn<S> = [S, (nextState: SetStateInput<S>) => void];\nexport type UseState<S> = CB<StateHandlerReturn<S>>;\n\ntype CreateStateReturn = {\n  reset: () => void;\n  registerStateKey: <S>(\n    initialState?: Maybe<StateInput<S>>,\n    onUpdate?: () => void,\n  ) => CB<StateHandlerReturn<S>>;\n};\n"],"mappings":";;;AAGA,SAAgB,YACd,eACmB;CACnB,MAAMA,QAEF,EACF,YAAY,EAAE,EACf;CAED,MAAMC,gBAGA,EAAE;AAER,QAAO;EACL;EACA;EACD;;;;;;;;;;;;;;CAeD,SAAS,iBACP,cACA,UAC2B;EAC3B,MAAM,MAAM,cAAc;AAC1B,gBAAc,KAAK,CAAC,cAAc,SAAS,CAAC;AAC5C,SAAO,QAAQ,KAAK,aAAa;;CAGnC,SAAS,QAAc;EACrB,MAAM,OAAO,SAAS;AACtB,QAAM,aAAa,EAAE;AACrB,gBAAc,SAAS,CAAC,eAAe,UACrC,QAAQ,OAAO,cAAc,KAAK,OAAO,CAC1C;;CAGH,SAAS,QACP,KACA,cACA,WACA;AACA,WAAS,CAAC,MAAM;AAChB,MAAI,KAAK,aAAa,cAAc,UAAU,CAAC;AAE/C,SAAO,SAAS,cAAqC;AACnD,UAAO,CACL,SAAS,CAAC,OACT,cACC,IAAI,KAAK,aAAa,WAAW,SAAS,CAAC,KAAK,CAAC,CACpD;;;CAIL,SAAS,UAAiB;AACxB,SAAO,MAAM;;CAGf,SAAS,IAAI,OAAe,OAAsB;EAChD,MAAM,YAAY,MAAM,WAAW;AACnC,QAAM,WAAW,SAAS;EAE1B,MAAM,GAAG,YAAY,cAAc;AAEnC,MAAI,WAAW,SAAS,CACtB,UAAS,OAAO,UAAU;AAG5B,MAAI,WAAW,cAAc,CAC3B,gBAAe"}

package/package.json

@@ -1,45 +1,43 @@
 {
-  "version": "2.0.0",
+  "version": "2.0.2",
   "license": "MIT",
-  "main": "./dist/cjs/vast.js",
-  "types": "./types/vast.d.ts",
+  "main": "./dist/vast.cjs",
+  "types": "./types/vast.d.cts",
   "name": "vast",
   "author": "ealush",
   "scripts": {
     "test": "vx test",
     "release": "vx release"
   },
-  "module": "./dist/es/vast.production.js",
+  "module": "./dist/vast.mjs",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ealush/vest.git",
+    "url": "git+https://github.com/ealush/vest.git",
     "directory": "packages/vast"
   },
   "bugs": {
     "url": "https://github.com/ealush/vest.git/issues"
   },
+  "dependencies": {
+    "vest-utils": "^2.0.2"
+  },
+  "unpkg": "./dist/vast.mjs",
+  "jsdelivr": "./dist/vast.mjs",
+  "vxAllowResolve": [],
   "exports": {
     ".": {
-      "development": {
-        "types": "./types/vast.d.ts",
-        "browser": "./dist/es/vast.development.js",
-        "umd": "./dist/umd/vast.development.js",
-        "import": "./dist/es/vast.development.js",
-        "require": "./dist/cjs/vast.development.js",
-        "node": "./dist/cjs/vast.development.js",
-        "module": "./dist/es/vast.development.js",
-        "default": "./dist/cjs/vast.development.js"
-      },
-      "types": "./types/vast.d.ts",
-      "browser": "./dist/es/vast.production.js",
-      "umd": "./dist/umd/vast.production.js",
-      "import": "./dist/es/vast.production.js",
-      "require": "./dist/cjs/vast.production.js",
-      "node": "./dist/cjs/vast.production.js",
-      "module": "./dist/es/vast.production.js",
-      "default": "./dist/cjs/vast.production.js"
+      "types": "./types/vast.d.cts",
+      "require": "./dist/vast.cjs",
+      "import": "./dist/vast.mjs"
+    },
+    "./*": {
+      "types": "./types/vast.d.cts",
+      "default": "./*"
     },
     "./package.json": "./package.json",
-    "./": "./"
+    "./vast": "./types/vast.d.cts",
+    "./vast.d.ts": "./types/vast.d.ts",
+    "./types/*": "./types/*",
+    "./dist/*": "./dist/*"
   }
 }

package/src/__tests__/vast.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+import { createState } from '../vast';
+
+let state = createState();
+
+describe('vast state', () => {
+  beforeEach(() => {
+    state = createState();
+  });
+
+  describe('createState', () => {
+    it('Should return all stateRef methods', () => {
+      expect(state).toMatchInlineSnapshot(`
+        {
+          "registerStateKey": [Function],
+          "reset": [Function],
+        }
+      `);
+    });
+  });
+
+  describe('state.registerStateKey', () => {
+    it('Should return a function', () => {
+      expect(typeof state.registerStateKey()).toBe('function');
+    });
+
+    it('Should append another state key on each call', () => {
+      const stateValues = Array.from({ length: 100 }, () => Math.random());
+      const stateGetters = stateValues.map(value =>
+        state.registerStateKey(value),
+      );
+      expect(
+        stateGetters.every(
+          (stateGetter, i) => stateGetter()[0] === stateValues[i],
+        ),
+      ).toBe(true);
+      expect(stateGetters).toHaveLength(100);
+    });
+
+    describe('When initial value is a function', () => {
+      it('Should generate initial state from key', () => {
+        const initialStateKey = { key: 'value' };
+        const stateGetter = state.registerStateKey(() => initialStateKey);
+        expect(stateGetter()[0]).toBe(initialStateKey);
+      });
+    });
+
+    describe('When initial value is not a function', () => {
+      it('Should use provided value as initial state', () => {
+        const stateValue = { key: 'value' };
+        const stateGetter = state.registerStateKey(stateValue);
+        expect(stateGetter()[0]).toBe(stateValue);
+      });
+    });
+
+    describe('When initial value is not provided', () => {
+      it('Should set initial state to undefined', () => {
+        const stateGetter = state.registerStateKey();
+        expect(stateGetter()[0]).toBeUndefined();
+      });
+    });
+  });
+
+  describe('State key function', () => {
+    it('Should return an Array with two elements', () => {
+      expect(state.registerStateKey()()).toHaveLength(2);
+      expect(state.registerStateKey('some value')()).toMatchInlineSnapshot(`
+        [
+          "some value",
+          [Function],
+        ]
+      `);
+    });
+
+    describe('getting current value', () => {
+      it('Should have current value in the first array element', () => {
+        const stateGetter = state.registerStateKey('Some Value');
+        expect(stateGetter()[0]).toBe('Some Value');
+      });
+    });
+
+    describe('updating the state', () => {
+      it('Should contain state updater in the second array element', () => {
+        const stateGetter = state.registerStateKey('Some Value');
+        expect(typeof stateGetter()[1]).toBe('function');
+      });
+
+      it('Should update the state with provided value', () => {
+        const stateGetter = state.registerStateKey({ key: 'first-value' });
+        const [, valueSetter] = stateGetter();
+        const nextValue = { key: 'second-value' };
+        valueSetter(nextValue);
+        expect(stateGetter()[0]).toBe(nextValue);
+      });
+
+      describe('When passing a function', () => {
+        it('Should update the state with the result of the function', () => {
+          const stateGetter = state.registerStateKey({ key: 'first-value' });
+          const [, valueSetter] = stateGetter();
+          const nextValue = { key: 'second-value' };
+          valueSetter(() => nextValue);
+          expect(stateGetter()[0]).toBe(nextValue);
+        });
+
+        it('Should pass the function the current state value', () => {
+          return new Promise<void>(done => {
+            const stateGetter = state.registerStateKey('555');
+            const [currentState, valueSetter] = stateGetter();
+            expect(currentState).toBe('555');
+
+            valueSetter(prevState => {
+              expect(prevState).toBe('555');
+              done();
+              return prevState;
+            });
+          });
+        });
+      });
+    });
+  });
+
+  describe('onStateChange and onUpdate handlers', () => {
+    it('Should run onStateChange handler when updating the state', () => {
+      const onStateChange = vi.fn();
+      state = createState(onStateChange);
+
+      const useKey1 = state.registerStateKey('v1');
+      const useKey2 = state.registerStateKey('v2');
+      expect(onStateChange).toHaveBeenCalledTimes(2);
+      useKey1()[1]('v1_1');
+      expect(onStateChange).toHaveBeenCalledTimes(3);
+      useKey2()[1]('v2_1');
+      expect(onStateChange).toHaveBeenCalledTimes(4);
+      expect(onStateChange).toHaveBeenCalledWith();
+    });
+
+    it('Should run onUpdate handler when updating the key', () => {
+      const onUpdate1 = vi.fn();
+      const onUpdate2 = vi.fn();
+      state = createState();
+
+      const useKey1 = state.registerStateKey('v1', onUpdate1);
+      const useKey2 = state.registerStateKey('v2', onUpdate2);
+      expect(onUpdate1).toHaveBeenCalledTimes(1);
+      expect(onUpdate1).toHaveBeenCalledWith('v1', undefined);
+      expect(onUpdate2).toHaveBeenCalledTimes(1);
+      const [, setKey1] = useKey1();
+      const [, setKey2] = useKey2();
+      setKey1('v1_1');
+      expect(onUpdate1).toHaveBeenCalledTimes(2);
+
+      // pass current state + previous state
+      expect(onUpdate1).toHaveBeenCalledWith('v1_1', 'v1');
+      setKey1('v1_2');
+      expect(onUpdate1).toHaveBeenCalledWith('v1_2', 'v1_1');
+      expect(onUpdate2).toHaveBeenCalledTimes(1);
+      setKey2('v2_1');
+      expect(onUpdate2).toHaveBeenCalledTimes(2);
+      expect(onUpdate2).toHaveBeenCalledWith('v2_1', 'v2');
+    });
+
+    it('Should first run onUpdate and then onStateChange', () => {
+      const onUpdate = vi.fn();
+      const onChange = vi.fn();
+      state = createState(onChange);
+
+      state.registerStateKey('v1', onUpdate);
+      expect(onUpdate.mock.invocationCallOrder[0]).toBeLessThan(
+        onChange.mock.invocationCallOrder[0],
+      );
+    });
+  });
+
+  describe('state.reset', () => {
+    it('Should fill up the state with registered keys', () => {
+      const s1 = state.registerStateKey(111);
+      const s2 = state.registerStateKey(222);
+      const s3 = state.registerStateKey(333);
+      const s4 = state.registerStateKey(444);
+      s1()[1](555);
+      s2()[1](666);
+      s3()[1](777);
+      s4()[1](888);
+
+      // sanity
+      expect(s1()[0]).toBe(555);
+      expect(s2()[0]).toBe(666);
+      expect(s3()[0]).toBe(777);
+      expect(s4()[0]).toBe(888);
+
+      state.reset();
+
+      // testing now that everything is back to initial value
+      expect(s1()[0]).toBe(111);
+      expect(s2()[0]).toBe(222);
+      expect(s3()[0]).toBe(333);
+      expect(s4()[0]).toBe(444);
+    });
+
+    it('Should allow setting a value after a state reset', () => {
+      const stateGetter = state.registerStateKey(() => 'hello!');
+      const [, stateSetter] = stateGetter();
+      state.reset();
+      stateSetter('Good Bye!');
+      expect(stateGetter()[0]).toBe('Good Bye!');
+    });
+  });
+});

package/src/vast.ts

@@ -0,0 +1,103 @@
+import { CB, DynamicValue, Maybe, isFunction, dynamicValue } from 'vest-utils';
+
+// eslint-disable-next-line max-lines-per-function
+export function createState(
+  onStateChange?: (...args: unknown[]) => unknown,
+): CreateStateReturn {
+  const state: {
+    references: unknown[];
+  } = {
+    references: [],
+  };
+
+  const registrations: [
+    unknown,
+    (<S>(currentState: S, prevState: S) => void)?,
+  ][] = [];
+
+  return {
+    registerStateKey,
+    reset,
+  };
+
+  /**
+   * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
+   *
+   * @example
+   *
+   * const useColor = state.registerStateKey("blue");
+   *
+   * let [color, setColor] = useColor(); // -> ["blue", Function]
+   *
+   * setColor("green");
+   *
+   * useColor()[0]; -> "green"
+   */
+  function registerStateKey<S>(
+    initialState?: Maybe<StateInput<S>>,
+    onUpdate?: () => void,
+  ): CB<StateHandlerReturn<S>> {
+    const key = registrations.length;
+    registrations.push([initialState, onUpdate]);
+    return initKey(key, initialState);
+  }
+
+  function reset(): void {
+    const prev = current();
+    state.references = [];
+    registrations.forEach(([initialValue], index) =>
+      initKey(index, initialValue, prev[index]),
+    );
+  }
+
+  function initKey<S>(
+    key: number,
+    initialState?: Maybe<StateInput<S>>,
+    prevState?: Maybe<S>,
+  ) {
+    current().push();
+    set(key, dynamicValue(initialState, prevState));
+
+    return function useStateKey(): StateHandlerReturn<S> {
+      return [
+        current()[key],
+        (nextState: SetStateInput<S>) =>
+          set(key, dynamicValue(nextState, current()[key])),
+      ];
+    };
+  }
+
+  function current(): any[] {
+    return state.references;
+  }
+
+  function set(index: number, value: unknown): void {
+    const prevValue = state.references[index];
+    state.references[index] = value;
+
+    const [, onUpdate] = registrations[index];
+
+    if (isFunction(onUpdate)) {
+      onUpdate(value, prevValue);
+    }
+
+    if (isFunction(onStateChange)) {
+      onStateChange();
+    }
+  }
+}
+
+type StateInput<S> = DynamicValue<S, [prevState?: S]>;
+type SetStateInput<S> = DynamicValue<S, [prevState: S]>;
+
+export type State = CreateStateReturn;
+export type StateHandlerReturn<S> = [S, (nextState: SetStateInput<S>) => void];
+export type UseState<S> = CB<StateHandlerReturn<S>>;
+
+type CreateStateReturn = {
+  reset: () => void;
+  registerStateKey: <S>(
+    initialState?: Maybe<StateInput<S>>,
+    onUpdate?: () => void,
+  ) => CB<StateHandlerReturn<S>>;
+};

package/types/vast.d.cts

@@ -0,0 +1,16 @@
+import { CB, DynamicValue, Maybe } from "vest-utils";
+
+//#region src/vast.d.ts
+declare function createState(onStateChange?: (...args: unknown[]) => unknown): CreateStateReturn;
+type StateInput<S> = DynamicValue<S, [prevState?: S]>;
+type SetStateInput<S> = DynamicValue<S, [prevState: S]>;
+type State = CreateStateReturn;
+type StateHandlerReturn<S> = [S, (nextState: SetStateInput<S>) => void];
+type UseState<S> = CB<StateHandlerReturn<S>>;
+type CreateStateReturn = {
+  reset: () => void;
+  registerStateKey: <S>(initialState?: Maybe<StateInput<S>>, onUpdate?: () => void) => CB<StateHandlerReturn<S>>;
+};
+//#endregion
+export { State, StateHandlerReturn, UseState, createState };
+//# sourceMappingURL=vast.d.cts.map

package/types/vast.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vast.d.cts","names":["CB","DynamicValue","Maybe","createState","CreateStateReturn","StateInput","S","SetStateInput","State","StateHandlerReturn","UseState"],"sources":["../src/vast.d.ts"],"sourcesContent":["import { CB, DynamicValue, Maybe } from 'vest-utils';\nexport declare function createState(onStateChange?: (...args: unknown[]) => unknown): CreateStateReturn;\ntype StateInput<S> = DynamicValue<S, [prevState?: S]>;\ntype SetStateInput<S> = DynamicValue<S, [prevState: S]>;\nexport type State = CreateStateReturn;\nexport type StateHandlerReturn<S> = [S, (nextState: SetStateInput<S>) => void];\nexport type UseState<S> = CB<StateHandlerReturn<S>>;\ntype CreateStateReturn = {\n    reset: () => void;\n    registerStateKey: <S>(initialState?: Maybe<StateInput<S>>, onUpdate?: () => void) => CB<StateHandlerReturn<S>>;\n};\nexport {};\n"],"mappings":";;;iBACwBG,WAAAA,mDAA8DC;KACjFC,gBAAgBJ,aAAaK,gBAAgBA;AADlD,KAEKC,aAF8B,CAAA,CAAA,CAAA,GAEXN,YAF8DG,CAEjDE,CAFiDF,EAAAA,CAAAA,SAAiB,EAEnDE,CAFmD,CAAA,CAAA;AAClGD,KAEOG,KAAAA,GAAQJ,iBAFL;AAAmBE,KAGtBG,kBAHsBH,CAAAA,CAAAA,CAAAA,GAAAA,CAGGA,CAHHA,EAAAA,CAAAA,SAAAA,EAGkBC,aAHlBD,CAGgCA,CAHhCA,CAAAA,EAAAA,GAAAA,IAAAA,CAAAA;AAAgBA,KAItCI,QAJsCJ,CAAAA,CAAAA,CAAAA,GAIxBN,EAJwBM,CAIrBG,kBAJqBH,CAIFA,CAJEA,CAAAA,CAAAA;KAK7CF,iBAAAA,GALgBH;EAAY,KAAA,EAAA,GAAA,GAAA,IAAA;EAC5BM,gBAAa,EAAA,CAAA,CAAA,CAAAD,CAAAA,YAAA,CAAA,EAMuBJ,KANvB,CAM6BG,UAN7B,CAMwCC,CANxC,CAAA,CAAA,EAAA,QAAA,CAAA,EAAA,GAAA,GAAA,IAAA,EAAA,GAMuEN,EANvE,CAM0ES,kBAN1E,CAM6FH,CAN7F,CAAA,CAAA;CAAmBA"}

package/types/vast.d.mts

@@ -0,0 +1,16 @@
+import { CB, DynamicValue, Maybe } from "vest-utils";
+
+//#region src/vast.d.ts
+declare function createState(onStateChange?: (...args: unknown[]) => unknown): CreateStateReturn;
+type StateInput<S> = DynamicValue<S, [prevState?: S]>;
+type SetStateInput<S> = DynamicValue<S, [prevState: S]>;
+type State = CreateStateReturn;
+type StateHandlerReturn<S> = [S, (nextState: SetStateInput<S>) => void];
+type UseState<S> = CB<StateHandlerReturn<S>>;
+type CreateStateReturn = {
+  reset: () => void;
+  registerStateKey: <S>(initialState?: Maybe<StateInput<S>>, onUpdate?: () => void) => CB<StateHandlerReturn<S>>;
+};
+//#endregion
+export { State, StateHandlerReturn, UseState, createState };
+//# sourceMappingURL=vast.d.mts.map

package/types/vast.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vast.d.mts","names":["CB","DynamicValue","Maybe","createState","CreateStateReturn","StateInput","S","SetStateInput","State","StateHandlerReturn","UseState"],"sources":["../src/vast.d.ts"],"sourcesContent":["import { CB, DynamicValue, Maybe } from 'vest-utils';\nexport declare function createState(onStateChange?: (...args: unknown[]) => unknown): CreateStateReturn;\ntype StateInput<S> = DynamicValue<S, [prevState?: S]>;\ntype SetStateInput<S> = DynamicValue<S, [prevState: S]>;\nexport type State = CreateStateReturn;\nexport type StateHandlerReturn<S> = [S, (nextState: SetStateInput<S>) => void];\nexport type UseState<S> = CB<StateHandlerReturn<S>>;\ntype CreateStateReturn = {\n    reset: () => void;\n    registerStateKey: <S>(initialState?: Maybe<StateInput<S>>, onUpdate?: () => void) => CB<StateHandlerReturn<S>>;\n};\nexport {};\n"],"mappings":";;;iBACwBG,WAAAA,mDAA8DC;KACjFC,gBAAgBJ,aAAaK,gBAAgBA;AADlD,KAEKC,aAF8B,CAAA,CAAA,CAAA,GAEXN,YAF8DG,CAEjDE,CAFiDF,EAAAA,CAAAA,SAAiB,EAEnDE,CAFmD,CAAA,CAAA;AAClGD,KAEOG,KAAAA,GAAQJ,iBAFL;AAAmBE,KAGtBG,kBAHsBH,CAAAA,CAAAA,CAAAA,GAAAA,CAGGA,CAHHA,EAAAA,CAAAA,SAAAA,EAGkBC,aAHlBD,CAGgCA,CAHhCA,CAAAA,EAAAA,GAAAA,IAAAA,CAAAA;AAAgBA,KAItCI,QAJsCJ,CAAAA,CAAAA,CAAAA,GAIxBN,EAJwBM,CAIrBG,kBAJqBH,CAIFA,CAJEA,CAAAA,CAAAA;KAK7CF,iBAAAA,GALgBH;EAAY,KAAA,EAAA,GAAA,GAAA,IAAA;EAC5BM,gBAAa,EAAA,CAAA,CAAA,CAAAD,CAAAA,YAAA,CAAA,EAMuBJ,KANvB,CAM6BG,UAN7B,CAMwCC,CANxC,CAAA,CAAA,EAAA,QAAA,CAAA,EAAA,GAAA,GAAA,IAAA,EAAA,GAMuEN,EANvE,CAM0ES,kBAN1E,CAM6FH,CAN7F,CAAA,CAAA;CAAmBA"}

package/types/vast.d.ts

@@ -1,13 +1,16 @@
-declare function createState(onStateChange?: (...args: unknown[]) => unknown): TCreateStateReturn;
-type TStateInput<S> = S | ((prevState?: S) => S);
-type TSetStateInput<S> = S | ((prevState: S) => S);
-type TState = ReturnType<typeof createState>;
-type TStateHandlerReturn<S> = [
-    S,
-    (nextState: TSetStateInput<S>) => void
-];
-type TCreateStateReturn = {
-    reset: () => void;
-    registerStateKey: <S>(initialState?: TStateInput<S> | undefined, onUpdate?: (() => void) | undefined) => () => TStateHandlerReturn<S>;
+import { CB, DynamicValue, Maybe } from "vest-utils";
+
+//#region src/vast.d.ts
+declare function createState(onStateChange?: (...args: unknown[]) => unknown): CreateStateReturn;
+type StateInput<S> = DynamicValue<S, [prevState?: S]>;
+type SetStateInput<S> = DynamicValue<S, [prevState: S]>;
+type State = CreateStateReturn;
+type StateHandlerReturn<S> = [S, (nextState: SetStateInput<S>) => void];
+type UseState<S> = CB<StateHandlerReturn<S>>;
+type CreateStateReturn = {
+  reset: () => void;
+  registerStateKey: <S>(initialState?: Maybe<StateInput<S>>, onUpdate?: () => void) => CB<StateHandlerReturn<S>>;
 };
-export { createState, TState, TStateHandlerReturn };
+//#endregion
+export { State, StateHandlerReturn, UseState, createState };
+//# sourceMappingURL=vast.d.cts.map

package/vitest.config.ts

@@ -0,0 +1,21 @@
+import path, { resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+import { defineConfig } from 'vitest/config';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default defineConfig({
+  test: {
+    globals: true,
+    include: ['./**/__tests__/*.test.ts'],
+    setupFiles: [resolve(__dirname, '../../', 'vx/config/vitest')],
+  },
+  root: __dirname,
+  resolve: {
+    alias: {
+      vast: resolve(__dirname, 'src/vast.ts'),
+    },
+  },
+});

package/dist/cjs/package.json

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

package/dist/cjs/vast.development.js

@@ -1,81 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function isFunction(value) {
-    return typeof value === 'function';
-}
-
-function optionalFunctionValue(value) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    return isFunction(value) ? value.apply(void 0, args) : value;
-}
-
-// eslint-disable-next-line max-lines-per-function
-function createState(onStateChange) {
-    var state = {
-        references: []
-    };
-    var registrations = [];
-    return {
-        registerStateKey: registerStateKey,
-        reset: reset
-    };
-    /**
-     * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
-     *
-     * @example
-     *
-     * const useColor = state.registerStateKey("blue");
-     *
-     * let [color, setColor] = useColor(); // -> ["blue", Function]
-     *
-     * setColor("green");
-     *
-     * useColor()[0]; -> "green"
-     */
-    function registerStateKey(initialState, onUpdate) {
-        var key = registrations.length;
-        registrations.push([initialState, onUpdate]);
-        return initKey(key, initialState);
-    }
-    function reset() {
-        var prev = current();
-        state.references = [];
-        registrations.forEach(function (_a, index) {
-            var initialValue = _a[0];
-            return initKey(index, initialValue, prev[index]);
-        });
-    }
-    function initKey(key, initialState, prevState) {
-        current().push();
-        set(key, optionalFunctionValue(initialState, prevState));
-        return function useStateKey() {
-            return [
-                current()[key],
-                function (nextState) {
-                    return set(key, optionalFunctionValue(nextState, current()[key]));
-                },
-            ];
-        };
-    }
-    function current() {
-        return state.references;
-    }
-    function set(index, value) {
-        var prevValue = state.references[index];
-        state.references[index] = value;
-        var _a = registrations[index], onUpdate = _a[1];
-        if (isFunction(onUpdate)) {
-            onUpdate(value, prevValue);
-        }
-        if (isFunction(onStateChange)) {
-            onStateChange();
-        }
-    }
-}
-
-exports.createState = createState;

package/dist/cjs/vast.js

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

package/dist/cjs/vast.production.js

@@ -1 +0,0 @@
-"use strict";function e(e){return"function"==typeof e}function r(r){for(var n=[],t=1;t<arguments.length;t++)n[t-1]=arguments[t];return e(r)?r.apply(void 0,n):r}Object.defineProperty(exports,"__esModule",{value:!0}),exports.createState=function(n){function t(e,n,t){return c.references.push(),u(e,r(n,t)),function(){return[c.references[e],function(n){return u(e,r(n,c.references[e]))}]}}function u(r,t){var u=c.references[r];c.references[r]=t,e(r=f[r][1])&&r(t,u),e(n)&&n()}var c={references:[]},f=[];return{registerStateKey:function(e,r){var n=f.length;return f.push([e,r]),t(n,e)},reset:function(){var e=c.references;c.references=[],f.forEach((function(r,n){return t(n,r[0],e[n])}))}}};

package/dist/es/package.json

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

package/dist/es/vast.development.js

@@ -1,77 +0,0 @@
-function isFunction(value) {
-    return typeof value === 'function';
-}
-
-function optionalFunctionValue(value) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    return isFunction(value) ? value.apply(void 0, args) : value;
-}
-
-// eslint-disable-next-line max-lines-per-function
-function createState(onStateChange) {
-    var state = {
-        references: []
-    };
-    var registrations = [];
-    return {
-        registerStateKey: registerStateKey,
-        reset: reset
-    };
-    /**
-     * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
-     *
-     * @example
-     *
-     * const useColor = state.registerStateKey("blue");
-     *
-     * let [color, setColor] = useColor(); // -> ["blue", Function]
-     *
-     * setColor("green");
-     *
-     * useColor()[0]; -> "green"
-     */
-    function registerStateKey(initialState, onUpdate) {
-        var key = registrations.length;
-        registrations.push([initialState, onUpdate]);
-        return initKey(key, initialState);
-    }
-    function reset() {
-        var prev = current();
-        state.references = [];
-        registrations.forEach(function (_a, index) {
-            var initialValue = _a[0];
-            return initKey(index, initialValue, prev[index]);
-        });
-    }
-    function initKey(key, initialState, prevState) {
-        current().push();
-        set(key, optionalFunctionValue(initialState, prevState));
-        return function useStateKey() {
-            return [
-                current()[key],
-                function (nextState) {
-                    return set(key, optionalFunctionValue(nextState, current()[key]));
-                },
-            ];
-        };
-    }
-    function current() {
-        return state.references;
-    }
-    function set(index, value) {
-        var prevValue = state.references[index];
-        state.references[index] = value;
-        var _a = registrations[index], onUpdate = _a[1];
-        if (isFunction(onUpdate)) {
-            onUpdate(value, prevValue);
-        }
-        if (isFunction(onStateChange)) {
-            onStateChange();
-        }
-    }
-}
-
-export { createState };

package/dist/es/vast.production.js

@@ -1 +0,0 @@
-function e(e){return"function"==typeof e}function r(r){for(var n=[],t=1;t<arguments.length;t++)n[t-1]=arguments[t];return e(r)?r.apply(void 0,n):r}export function createState(n){function t(e,n,t){return c.references.push(),f(e,r(n,t)),function(){return[c.references[e],function(n){return f(e,r(n,c.references[e]))}]}}function f(r,t){var f=c.references[r];c.references[r]=t,e(r=u[r][1])&&r(t,f),e(n)&&n()}var c={references:[]},u=[];return{registerStateKey:function(e,r){var n=u.length;return u.push([e,r]),t(n,e)},reset:function(){var e=c.references;c.references=[],u.forEach((function(r,n){return t(n,r[0],e[n])}))}}}

package/dist/umd/vast.development.js

@@ -1,87 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vast = {}));
-}(this, (function (exports) { 'use strict';
-
-  function isFunction(value) {
-      return typeof value === 'function';
-  }
-
-  function optionalFunctionValue(value) {
-      var args = [];
-      for (var _i = 1; _i < arguments.length; _i++) {
-          args[_i - 1] = arguments[_i];
-      }
-      return isFunction(value) ? value.apply(void 0, args) : value;
-  }
-
-  // eslint-disable-next-line max-lines-per-function
-  function createState(onStateChange) {
-      var state = {
-          references: []
-      };
-      var registrations = [];
-      return {
-          registerStateKey: registerStateKey,
-          reset: reset
-      };
-      /**
-       * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
-       *
-       * @example
-       *
-       * const useColor = state.registerStateKey("blue");
-       *
-       * let [color, setColor] = useColor(); // -> ["blue", Function]
-       *
-       * setColor("green");
-       *
-       * useColor()[0]; -> "green"
-       */
-      function registerStateKey(initialState, onUpdate) {
-          var key = registrations.length;
-          registrations.push([initialState, onUpdate]);
-          return initKey(key, initialState);
-      }
-      function reset() {
-          var prev = current();
-          state.references = [];
-          registrations.forEach(function (_a, index) {
-              var initialValue = _a[0];
-              return initKey(index, initialValue, prev[index]);
-          });
-      }
-      function initKey(key, initialState, prevState) {
-          current().push();
-          set(key, optionalFunctionValue(initialState, prevState));
-          return function useStateKey() {
-              return [
-                  current()[key],
-                  function (nextState) {
-                      return set(key, optionalFunctionValue(nextState, current()[key]));
-                  },
-              ];
-          };
-      }
-      function current() {
-          return state.references;
-      }
-      function set(index, value) {
-          var prevValue = state.references[index];
-          state.references[index] = value;
-          var _a = registrations[index], onUpdate = _a[1];
-          if (isFunction(onUpdate)) {
-              onUpdate(value, prevValue);
-          }
-          if (isFunction(onStateChange)) {
-              onStateChange();
-          }
-      }
-  }
-
-  exports.createState = createState;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-})));

package/dist/umd/vast.production.js

@@ -1 +0,0 @@
-"use strict";!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).vast={})}(this,(function(e){function n(e){return"function"==typeof e}function r(e){for(var r=[],t=1;t<arguments.length;t++)r[t-1]=arguments[t];return n(e)?e.apply(void 0,r):e}e.createState=function(e){function t(e,n,t){return o.references.push(),f(e,r(n,t)),function(){return[o.references[e],function(n){return f(e,r(n,o.references[e]))}]}}function f(r,t){var f=o.references[r];o.references[r]=t,n(r=u[r][1])&&r(t,f),n(e)&&e()}var o={references:[]},u=[];return{registerStateKey:function(e,n){var r=u.length;return u.push([e,n]),t(r,e)},reset:function(){var e=o.references;o.references=[],u.forEach((function(n,r){return t(r,n[0],e[r])}))}}},Object.defineProperty(e,"__esModule",{value:!0})}));

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "declarationMap": true,
-    "declarationDir": "./types",
-    "outDir": "./dist"
-  }
-}