vast 1.0.0 → 2.0.0-dev-031d95

package/CHANGELOG.md

@@ -0,0 +1,49 @@
+# vast - Changelog
+
+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-13
+### 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)
+
+## 1.0.11 - 2021-07-02
+
+### Fixed and improved
+
+- 34e0414 improved conditions (undefined)
+- 33f4e46 release (undefined)
+- 6fe40c7 better bundle (undefined)
+- c6387ab before ts settings (undefined)
+- c0e9708 generate correct d.ts file (undefined)
+- 8e01b8e x (undefined)
+- afb3960 x (undefined)
+- e0a8463 add changelog support (undefined)
+- cc46c38 current (undefined)
+- b6db1c6 transform any to unknowns (ealush)
+- 81aad51 fix most tests (ealush)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 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,65 @@
+# 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.
+
+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.
+
+## Installation
+
+```
+npm i vast
+```
+
+## Usage
+
+```js
+import { createState } from 'vast';
+
+const state = createState(); // Creates a state reference.
+
+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
+
+const [color, setColor] = useColor(); // ["blue", Function]
+setColor('red'); // set the color to "red"
+```
+
+The next time you will call `useColor` the value of `color` will be `"red"`.
+
+You can also set a computed value by passing in a function:
+
+```js
+const [color, setColor] = useColor(); // ["blue", Function]
+setColor(currentColor => (color === 'red' ? 'blue' : 'red'));
+```
+
+## Subscribing to changes
+
+### Getting notified for every change in the state
+
+**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:
+
+```js
+const state = createState(() => console.log('the state was updated!'));
+```
+
+Now on every state change, this callback will run.
+
+Alternatively, if you need more granularity, you can subscribe to specific state keys.
+
+### Subscribing to specific state key updates
+
+If you need to react to specific changes in your state, you can add an `onUpdate` callback to those state key registrations:
+
+```js
+const useColor = state.registerStateKey(
+  'red',
+  (currentState, previousState) => {
+    console.log(`the color changed from ${previousState} to ${currentState}!`);
+  }
+);
+```
+
+Now, whenever a state update happens in that key, your callback will run, providing the previous and changed value as well.

package/dist/cjs/package.json

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

package/dist/cjs/vast.development.js

@@ -0,0 +1,81 @@
+'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

@@ -0,0 +1,7 @@
+'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

@@ -0,0 +1 @@
+"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

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

package/dist/es/vast.development.js

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1 @@
+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

@@ -0,0 +1,87 @@
+(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

@@ -0,0 +1 @@
+"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/package.json

@@ -1,11 +1,45 @@
 {
+  "version": "2.0.0-dev-031d95",
+  "license": "MIT",
+  "main": "./dist/cjs/vast.js",
+  "types": "./types/vast.d.ts",
   "name": "vast",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
+  "author": "ealush",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vx test",
+    "release": "vx release"
   },
-  "author": "",
-  "license": "ISC"
+  "module": "./dist/es/vast.production.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ealush/vest.git",
+    "directory": "packages/vast"
+  },
+  "bugs": {
+    "url": "https://github.com/ealush/vest.git/issues"
+  },
+  "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"
+    },
+    "./package.json": "./package.json",
+    "./": "./"
+  }
 }

package/tsconfig.json

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

package/types/vast.d.ts

@@ -0,0 +1,13 @@
+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>;
+};
+export { createState, TState, TStateHandlerReturn };