vest-utils 0.1.1 → 1.0.0-dev-ec989a

package/dist/umd/vest-utils.development.js

@@ -5,32 +5,26 @@
 })(this, (function (exports) { 'use strict';
 
   function bindNot(fn) {
-      return function () {
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments[_i];
-          }
-          return !fn.apply(void 0, args);
-      };
+      return (...args) => !fn(...args);
   }
 
   function isNumeric(value) {
-      var str = String(value);
-      var num = Number(value);
-      var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
+      const str = String(value);
+      const num = Number(value);
+      const result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
       return Boolean(result);
   }
-  var isNotNumeric = bindNot(isNumeric);
+  const isNotNumeric = bindNot(isNumeric);
 
   function numberEquals(value, eq) {
       return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
   }
-  var numberNotEquals = bindNot(numberEquals);
+  const numberNotEquals = bindNot(numberEquals);
 
   function lengthEquals(value, arg1) {
       return numberEquals(value.length, arg1);
   }
-  var lengthNotEquals = bindNot(lengthEquals);
+  const lengthNotEquals = bindNot(lengthEquals);
 
   function greaterThan(value, gt) {
       return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
@@ -43,145 +37,55 @@
   /**
    * Creates a cache function
    */
-  function createCache(maxSize) {
-      if (maxSize === void 0) { maxSize = 1; }
-      var cacheStorage = [];
-      var cache = function (deps, cacheAction) {
-          var cacheHit = cache.get(deps);
+  function createCache(maxSize = 1) {
+      const cacheStorage = [];
+      const cache = (deps, cacheAction) => {
+          const cacheHit = cache.get(deps);
           // cache hit is not null
           if (cacheHit)
               return cacheHit[1];
-          var result = cacheAction();
+          const result = cacheAction();
           cacheStorage.unshift([deps.concat(), result]);
           if (longerThan(cacheStorage, maxSize))
               cacheStorage.length = maxSize;
           return result;
       };
       // invalidate an item in the cache by its dependencies
-      cache.invalidate = function (deps) {
-          var index = findIndex(deps);
+      cache.invalidate = (deps) => {
+          const index = findIndex(deps);
           if (index > -1)
               cacheStorage.splice(index, 1);
       };
       // Retrieves an item from the cache.
-      cache.get = function (deps) {
-          return cacheStorage[findIndex(deps)] || null;
-      };
+      cache.get = (deps) => cacheStorage[findIndex(deps)] || null;
       return cache;
       function findIndex(deps) {
-          return cacheStorage.findIndex(function (_a) {
-              var cachedDeps = _a[0];
-              return lengthEquals(deps, cachedDeps.length) &&
-                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-          });
+          return cacheStorage.findIndex(([cachedDeps]) => lengthEquals(deps, cachedDeps.length) &&
+              deps.every((dep, i) => dep === cachedDeps[i]));
       }
   }
 
   function isNull(value) {
       return value === null;
   }
-  var isNotNull = bindNot(isNull);
+  const isNotNull = bindNot(isNull);
 
   function isUndefined(value) {
       return value === undefined;
   }
-  var isNotUndefined = bindNot(isUndefined);
+  const isNotUndefined = bindNot(isUndefined);
 
   function isNullish(value) {
       return isNull(value) || isUndefined(value);
   }
-  var isNotNullish = bindNot(isNullish);
+  const isNotNullish = bindNot(isNullish);
 
   function asArray(possibleArg) {
       return [].concat(possibleArg);
   }
 
-  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;
-  }
-
-  function defaultTo(value, defaultValue) {
-      var _a;
-      return (_a = optionalFunctionValue(value)) !== null && _a !== void 0 ? _a : optionalFunctionValue(defaultValue);
-  }
-
-  // The module is named "isArrayValue" since it
-  // is conflicting with a nested npm dependency.
-  // We may need to revisit this in the future.
-  function isArray(value) {
-      return Boolean(Array.isArray(value));
-  }
-  var isNotArray = bindNot(isArray);
-
-  function last(values) {
-      var valuesArray = asArray(values);
-      return valuesArray[valuesArray.length - 1];
-  }
-
-  // This is kind of a map/filter in one function.
-  // Normally, behaves like a nested-array map,
-  // but returning `null` will drop the element from the array
-  function transform(array, cb) {
-      var res = [];
-      for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
-          var v = array_1[_i];
-          if (isArray(v)) {
-              res.push(transform(v, cb));
-          }
-          else {
-              var output = cb(v);
-              if (isNotNull(output)) {
-                  res.push(output);
-              }
-          }
-      }
-      return res;
-  }
-  function valueAtPath(array, path) {
-      return getCurrent(array, path)[last(path)];
-  }
-  function setValueAtPath(array, path, value) {
-      var current = getCurrent(array, path);
-      current[last(path)] = value;
-      return array;
-  }
-  function flatten(values) {
-      return asArray(values).reduce(function (acc, value) {
-          if (isArray(value)) {
-              return acc.concat(flatten(value));
-          }
-          return asArray(acc).concat(value);
-      }, []);
-  }
-  function getCurrent(array, path) {
-      var current = array;
-      for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
-          var p = _a[_i];
-          current[p] = defaultTo(current[p], []);
-          current = current[p];
-      }
-      return current;
-  }
-
-  var nestedArray = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    transform: transform,
-    valueAtPath: valueAtPath,
-    setValueAtPath: setValueAtPath,
-    flatten: flatten,
-    getCurrent: getCurrent
-  });
-
   function callEach(arr) {
-      return arr.forEach(function (fn) { return fn(); });
+      return arr.forEach(fn => fn());
   }
 
   /**
@@ -191,12 +95,25 @@
       return Object.prototype.hasOwnProperty.call(obj, key);
   }
 
+  function isFunction(value) {
+      return typeof value === 'function';
+  }
+
   function isPromise(value) {
       return value && isFunction(value.then);
   }
 
+  function optionalFunctionValue(value, ...args) {
+      return isFunction(value) ? value(...args) : value;
+  }
+
   var assign = Object.assign;
 
+  function defaultTo(value, defaultValue) {
+      var _a;
+      return (_a = optionalFunctionValue(value)) !== null && _a !== void 0 ? _a : optionalFunctionValue(defaultValue);
+  }
+
   function invariant(condition, 
   // eslint-disable-next-line @typescript-eslint/ban-types
   message) {
@@ -227,28 +144,33 @@
       return !!value === value;
   }
 
+  function last(values) {
+      const valuesArray = asArray(values);
+      return valuesArray[valuesArray.length - 1];
+  }
+
   function deferThrow(message) {
-      setTimeout(function () {
+      setTimeout(() => {
           throw new Error(message);
       }, 0);
   }
 
   function createBus() {
-      var listeners = {};
+      const listeners = {};
       return {
-          emit: function (event, data) {
-              listener(event).forEach(function (handler) {
+          emit(event, data) {
+              listener(event).forEach(handler => {
                   handler(data);
               });
           },
-          on: function (event, handler) {
+          on(event, handler) {
               listeners[event] = listener(event).concat(handler);
               return {
-                  off: function () {
-                      listeners[event] = listener(event).filter(function (h) { return h !== handler; });
-                  }
+                  off() {
+                      listeners[event] = listener(event).filter(h => h !== handler);
+                  },
               };
-          }
+          },
       };
       function listener(event) {
           return listeners[event] || [];
@@ -263,17 +185,15 @@
   /**
    * @returns a unique numeric id.
    */
-  var seq = genSeq();
+  const seq = genSeq();
   function genSeq(namespace) {
-      return (function (n) { return function () {
-          return "".concat(namespace ? namespace + '_' : '').concat(n++);
-      }; })(0);
+      return ((n) => () => `${namespace ? namespace + '_' : ''}${n++}`)(0);
   }
 
   function mapFirst(array, callback) {
-      var broke = false;
-      var breakoutValue = null;
-      for (var i = 0; i < array.length; i++) {
+      let broke = false;
+      let breakoutValue = null;
+      for (let i = 0; i < array.length; i++) {
           callback(array[i], breakout, i);
           if (broke) {
               return breakoutValue;
@@ -287,6 +207,18 @@
       }
   }
 
+  function isObject(v) {
+      return typeof v === 'object' && !isNullish(v);
+  }
+
+  // The module is named "isArrayValue" since it
+  // is conflicting with a nested npm dependency.
+  // We may need to revisit this in the future.
+  function isArray(value) {
+      return Boolean(Array.isArray(value));
+  }
+  const isNotArray = bindNot(isArray);
+
   function isEmpty(value) {
       if (!value) {
           return true;
@@ -294,17 +226,79 @@
       else if (hasOwnProperty(value, 'length')) {
           return lengthEquals(value, 0);
       }
-      else if (typeof value === 'object') {
+      else if (isObject(value)) {
           return lengthEquals(Object.keys(value), 0);
       }
       return false;
   }
-  var isNotEmpty = bindNot(isEmpty);
+  const isNotEmpty = bindNot(isEmpty);
 
   function isPositive(value) {
       return greaterThan(value, 0);
   }
 
+  const regexp = /{(.*?)}/g;
+  function text(str, ...substitutions) {
+      const first = substitutions[0];
+      if (isObject(first)) {
+          return str.replace(regexp, (placeholder, key) => {
+              var _a;
+              return `${(_a = first[key]) !== null && _a !== void 0 ? _a : placeholder}`;
+          });
+      }
+      const subs = [...substitutions];
+      return str.replace(regexp, placeholder => {
+          return `${isEmpty(subs) ? placeholder : subs.shift()}`;
+      });
+  }
+
+  const STATE_WILD_CARD = '*';
+  function StateMachine(machine) {
+      let state = machine.initial;
+      const api = { getState, transition };
+      return api;
+      function getState() {
+          return state;
+      }
+      // eslint-disable-next-line complexity
+      function transition(action, payload) {
+          var _a, _b, _c;
+          const transitionTo = (_b = (_a = machine.states[state]) === null || _a === void 0 ? void 0 : _a[action]) !== null && _b !== void 0 ? _b : 
+          // @ts-expect-error - This is a valid state
+          (_c = machine.states[STATE_WILD_CARD]) === null || _c === void 0 ? void 0 : _c[action];
+          let target = transitionTo;
+          if (Array.isArray(target)) {
+              const [, conditional] = target;
+              if (!conditional(payload)) {
+                  return;
+              }
+              target = target[0];
+          }
+          if (!target || target === state) {
+              return;
+          }
+          state = target;
+      }
+  }
+
+  function createTinyState(initialValue) {
+      let value;
+      resetValue();
+      return () => [value, setValue, resetValue];
+      function setValue(nextValue) {
+          value = optionalFunctionValue(nextValue, value);
+      }
+      function resetValue() {
+          setValue(optionalFunctionValue(initialValue));
+      }
+  }
+
+  var tinyState = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createTinyState: createTinyState
+  });
+
+  exports.StateMachine = StateMachine;
   exports.StringObject = StringObject;
   exports.asArray = asArray;
   exports.assign = assign;
@@ -332,6 +326,7 @@
   exports.isNull = isNull;
   exports.isNullish = isNullish;
   exports.isNumeric = isNumeric;
+  exports.isObject = isObject;
   exports.isPositive = isPositive;
   exports.isPromise = isPromise;
   exports.isStringValue = isStringValue;
@@ -341,12 +336,11 @@
   exports.lengthNotEquals = lengthNotEquals;
   exports.longerThan = longerThan;
   exports.mapFirst = mapFirst;
-  exports.nestedArray = nestedArray;
   exports.numberEquals = numberEquals;
   exports.numberNotEquals = numberNotEquals;
   exports.optionalFunctionValue = optionalFunctionValue;
   exports.seq = seq;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
+  exports.text = text;
+  exports.tinyState = tinyState;
 
 }));

package/dist/umd/vest-utils.production.js

@@ -1 +1 @@
-!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((n="undefined"!=typeof globalThis?globalThis:n||self)["vest-utils"]={})}(this,(function(n){"use strict";function t(n){return function(){for(var t=[],r=0;r<arguments.length;r++)t[r]=arguments[r];return!n.apply(void 0,t)}}function r(n){var t=String(n),r=Number(n),e=!isNaN(parseFloat(t))&&!isNaN(Number(n))&&isFinite(r);return Boolean(e)}var e=t(r);function u(n,t){return r(n)&&r(t)&&Number(n)===Number(t)}var i=t(u);function o(n,t){return u(n.length,t)}var c=t(o);function f(n,t){return r(n)&&r(t)&&Number(n)>Number(t)}function a(n,t){return f(n.length,t)}function l(n){return null===n}var s=t(l);function v(n){return void 0===n}var h=t(v);function g(n){return l(n)||v(n)}var d=t(g);function p(n){return[].concat(n)}function N(n){return"function"==typeof n}function y(n){for(var t=[],r=1;r<arguments.length;r++)t[r-1]=arguments[r];return N(n)?n.apply(void 0,t):n}function b(n,t){var r;return null!==(r=y(n))&&void 0!==r?r:y(t)}function m(n){return Boolean(Array.isArray(n))}var E=t(m);function _(n){var t=p(n);return t[t.length-1]}function O(n,t){for(var r=n,e=0,u=t.slice(0,-1);e<u.length;e++){var i=u[e];r[i]=b(r[i],[]),r=r[i]}return r}var j=Object.freeze({__proto__:null,transform:function n(t,r){for(var e=[],u=0,i=t;u<i.length;u++){var o=i[u];if(m(o))e.push(n(o,r));else{var c=r(o);s(c)&&e.push(c)}}return e},valueAtPath:function(n,t){return O(n,t)[_(t)]},setValueAtPath:function(n,t,r){return O(n,t)[_(t)]=r,n},flatten:function n(t){return p(t).reduce((function(t,r){return m(r)?t.concat(n(r)):p(t).concat(r)}),[])},getCurrent:O});function w(n,t){return Object.prototype.hasOwnProperty.call(n,t)}var A=Object.assign;var P=Object.freeze({__proto__:null,createBus:function(){var n={};return{emit:function(n,r){t(n).forEach((function(n){n(r)}))},on:function(r,e){return n[r]=t(r).concat(e),{off:function(){n[r]=t(r).filter((function(n){return n!==e}))}}}};function t(t){return n[t]||[]}}}),S=T();function T(n){return t=0,function(){return"".concat(n?n+"_":"").concat(t++)};var t}function q(n){return!n||(w(n,"length")?o(n,0):"object"==typeof n&&o(Object.keys(n),0))}var F=t(q);n.StringObject=function(n){return new String(y(n))},n.asArray=p,n.assign=A,n.bindNot=t,n.bus=P,n.cache=function(n){void 0===n&&(n=1);var t=[],r=function(e,u){var i=r.get(e);if(i)return i[1];var o=u();return t.unshift([e.concat(),o]),a(t,n)&&(t.length=n),o};return r.invalidate=function(n){var r=e(n);r>-1&&t.splice(r,1)},r.get=function(n){return t[e(n)]||null},r;function e(n){return t.findIndex((function(t){var r=t[0];return o(n,r.length)&&n.every((function(n,t){return n===r[t]}))}))}},n.callEach=function(n){return n.forEach((function(n){return n()}))},n.defaultTo=b,n.deferThrow=function(n){setTimeout((function(){throw new Error(n)}),0)},n.either=function(n,t){return!!n!=!!t},n.genSeq=T,n.greaterThan=f,n.hasOwnProperty=w,n.invariant=function(n,t){if(!n)throw t instanceof String?t.valueOf():new Error(t?y(t):t)},n.isArray=m,n.isBoolean=function(n){return!!n===n},n.isEmpty=q,n.isFunction=N,n.isNotArray=E,n.isNotEmpty=F,n.isNotNull=s,n.isNotNullish=d,n.isNotNumeric=e,n.isNotUndefined=h,n.isNull=l,n.isNullish=g,n.isNumeric=r,n.isPositive=function(n){return f(n,0)},n.isPromise=function(n){return n&&N(n.then)},n.isStringValue=function(n){return String(n)===n},n.isUndefined=v,n.last=_,n.lengthEquals=o,n.lengthNotEquals=c,n.longerThan=a,n.mapFirst=function(n,t){for(var r=!1,e=null,u=0;u<n.length;u++)if(t(n[u],i,u),r)return e;function i(n,t){n&&(r=!0,e=t)}},n.nestedArray=j,n.numberEquals=u,n.numberNotEquals=i,n.optionalFunctionValue=y,n.seq=S,Object.defineProperty(n,"__esModule",{value:!0})}));
+!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((n="undefined"!=typeof globalThis?globalThis:n||self)["vest-utils"]={})}(this,(function(n){"use strict";function t(n){return(...t)=>!n(...t)}function e(n){const t=String(n),e=Number(n),r=!isNaN(parseFloat(t))&&!isNaN(Number(n))&&isFinite(e);return Boolean(r)}const r=t(e);function i(n,t){return e(n)&&e(t)&&Number(n)===Number(t)}const o=t(i);function u(n,t){return i(n.length,t)}const c=t(u);function s(n,t){return e(n)&&e(t)&&Number(n)>Number(t)}function f(n,t){return s(n.length,t)}function l(n){return null===n}const a=t(l);function h(n){return void 0===n}const d=t(h);function g(n){return l(n)||h(n)}const N=t(g);function p(n){return[].concat(n)}function y(n,t){return Object.prototype.hasOwnProperty.call(n,t)}function b(n){return"function"==typeof n}function v(n,...t){return b(n)?n(...t):n}var m=Object.assign;var E=Object.freeze({__proto__:null,createBus:function(){const n={};return{emit(n,e){t(n).forEach((n=>{n(e)}))},on:(e,r)=>(n[e]=t(e).concat(r),{off(){n[e]=t(e).filter((n=>n!==r))}})};function t(t){return n[t]||[]}}});const S=O();function O(n){return t=0,()=>`${n?n+"_":""}${t++}`;var t}function j(n){return"object"==typeof n&&!g(n)}function _(n){return Boolean(Array.isArray(n))}const w=t(_);function T(n){return!n||(y(n,"length")?u(n,0):!!j(n)&&u(Object.keys(n),0))}const A=t(T);const q=/{(.*?)}/g;var x=Object.freeze({__proto__:null,createTinyState:function(n){let t;return r(),()=>[t,e,r];function e(n){t=v(n,t)}function r(){e(v(n))}}});n.StateMachine=function(n){let t=n.initial;return{getState:function(){return t},transition:function(e,r){var i,o,u;let c=null!==(o=null===(i=n.states[t])||void 0===i?void 0:i[e])&&void 0!==o?o:null===(u=n.states["*"])||void 0===u?void 0:u[e];if(Array.isArray(c)){const[,n]=c;if(!n(r))return;c=c[0]}if(!c||c===t)return;t=c}}},n.StringObject=function(n){return new String(v(n))},n.asArray=p,n.assign=m,n.bindNot=t,n.bus=E,n.cache=function(n=1){const t=[],e=(r,i)=>{const o=e.get(r);if(o)return o[1];const u=i();return t.unshift([r.concat(),u]),f(t,n)&&(t.length=n),u};return e.invalidate=n=>{const e=r(n);e>-1&&t.splice(e,1)},e.get=n=>t[r(n)]||null,e;function r(n){return t.findIndex((([t])=>u(n,t.length)&&n.every(((n,e)=>n===t[e]))))}},n.callEach=function(n){return n.forEach((n=>n()))},n.defaultTo=function(n,t){var e;return null!==(e=v(n))&&void 0!==e?e:v(t)},n.deferThrow=function(n){setTimeout((()=>{throw new Error(n)}),0)},n.either=function(n,t){return!!n!=!!t},n.genSeq=O,n.greaterThan=s,n.hasOwnProperty=y,n.invariant=function(n,t){if(!n)throw t instanceof String?t.valueOf():new Error(t?v(t):t)},n.isArray=_,n.isBoolean=function(n){return!!n===n},n.isEmpty=T,n.isFunction=b,n.isNotArray=w,n.isNotEmpty=A,n.isNotNull=a,n.isNotNullish=N,n.isNotNumeric=r,n.isNotUndefined=d,n.isNull=l,n.isNullish=g,n.isNumeric=e,n.isObject=j,n.isPositive=function(n){return s(n,0)},n.isPromise=function(n){return n&&b(n.then)},n.isStringValue=function(n){return String(n)===n},n.isUndefined=h,n.last=function(n){const t=p(n);return t[t.length-1]},n.lengthEquals=u,n.lengthNotEquals=c,n.longerThan=f,n.mapFirst=function(n,t){let e=!1,r=null;for(let o=0;o<n.length;o++)if(t(n[o],i,o),e)return r;function i(n,t){n&&(e=!0,r=t)}},n.numberEquals=i,n.numberNotEquals=o,n.optionalFunctionValue=v,n.seq=S,n.text=function(n,...t){const e=t[0];if(j(e))return n.replace(q,((n,t)=>{var r;return`${null!==(r=e[t])&&void 0!==r?r:n}`}));const r=[...t];return n.replace(q,(n=>`${T(r)?n:r.shift()}`))},n.tinyState=x}));

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.1",
+  "version": "1.0.0-dev-ec989a",
   "name": "vest-utils",
   "author": "ealush",
   "scripts": {
@@ -44,4 +44,4 @@
     "./package.json": "./package.json",
     "./*": "./*"
   }
-}
+}

package/types/vest-utils.d.ts

@@ -17,20 +17,6 @@ type CacheApi<T = unknown> = {
     ] | null;
     invalidate(item: any): void;
 };
-declare function isNullish(value: any): value is null | undefined;
-declare const isNotNullish: (value: any) => boolean;
-declare namespace nestedArray {
-    type NestedArray<T> = Array<NestedArray<T> | T>;
-    // This is kind of a map/filter in one function.
-    // Normally, behaves like a nested-array map,
-    // but returning `null` will drop the element from the array
-    function transform<T>(array: NestedArray<T>, cb: (value: T) => NestedArray<T> | T | null): NestedArray<T>;
-    function valueAtPath<T>(array: NestedArray<T>, path: number[]): T | NestedArray<T>;
-    function setValueAtPath<T>(array: NestedArray<T>, path: number[], value: NestedArray<T> | T): NestedArray<T>;
-    function flatten<T>(values: NestedArray<T> | T): T[];
-    function getCurrent<T>(array: NestedArray<T>, path: number[]): NestedArray<T>;
-}
-declare function asArray<T>(possibleArg: T | T[]): T[];
 type DropFirst<T extends unknown[]> = T extends [
     unknown,
     ...infer U
@@ -38,6 +24,21 @@ type DropFirst<T extends unknown[]> = T extends [
 type Stringable = string | ((...args: any[]) => string);
 type CB = (...args: any[]) => any;
 type ValueOf<T> = T[keyof T];
+type OnReturn = {
+    off: () => void;
+};
+type BusType = {
+    on: (event: string, handler: CB) => OnReturn;
+    emit: (event: string, ...args: any[]) => void;
+};
+type TinyState<S> = () => [
+    value: S,
+    setValue: (next: S | ((prev: S) => S)) => void,
+    resetValue: () => void
+];
+declare function isNullish(value: any): value is null | undefined;
+declare const isNotNullish: (value: any) => boolean;
+declare function asArray<T>(possibleArg: T | T[]): T[];
 declare function callEach(arr: CB[]): void;
 /**
  * A safe hasOwnProperty access
@@ -51,7 +52,7 @@ declare const _default: {
     <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
     (target: object, ...sources: any[]): any;
 };
-declare function defaultTo<T>(value: T | ((...args: any[]) => T), defaultValue: T | (() => T)): T;
+declare function defaultTo<T>(value: T | void | null | ((...args: any[]) => T | void | null), defaultValue: T | (() => T)): T;
 declare function invariant(condition: any, 
 // eslint-disable-next-line @typescript-eslint/ban-types
 message?: String | Stringable): asserts condition;
@@ -71,13 +72,14 @@ declare namespace bus {
     type Stringable = string | ((...args: any[]) => string);
     type CB = (...args: any[]) => any;
     type ValueOf<T> = T[keyof T];
-    function createBus(): {
-        on: (event: string, handler: CB) => OnReturn;
-        emit: (event: string, ...args: any[]) => void;
-    };
+    function createBus(): BusType;
     type OnReturn = {
         off: () => void;
     };
+    type BusType = {
+        on: (event: string, handler: CB) => OnReturn;
+        emit: (event: string, ...args: any[]) => void;
+    };
 }
 /**
  * @returns a unique numeric id.
@@ -90,6 +92,7 @@ declare function greaterThan(value: number | string, gt: number | string): boole
 declare function longerThan(value: string | unknown[], arg1: string | number): boolean;
 declare function isNumeric(value: string | number): boolean;
 declare const isNotNumeric: (value: string | number) => boolean;
+declare function isObject(v: any): v is Record<any, any>;
 declare function lengthEquals(value: string | unknown[], arg1: string | number): boolean;
 declare const lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
 declare function numberEquals(value: string | number, eq: string | number): boolean;
@@ -106,6 +109,32 @@ declare const isNotArray: (value: unknown) => boolean;
 declare function isEmpty(value: unknown): boolean;
 declare const isNotEmpty: (value: unknown) => boolean;
 declare function isPositive(value: number | string): boolean;
-export { createCache as cache, CacheApi, isNullish, isNotNullish, nestedArray, asArray, callEach, hasOwnProperty, isPromise, optionalFunctionValue, _default as assign, defaultTo, invariant, StringObject, isStringValue, bindNot, either, isBoolean, last, deferThrow, bus, seq, genSeq, isFunction, mapFirst, greaterThan, longerThan, isNumeric, isNotNumeric, lengthEquals, lengthNotEquals, numberEquals, numberNotEquals, isNull, isNotNull, isUndefined, isNotUndefined, isArray, isNotArray, isEmpty, isNotEmpty, isPositive };
+declare function text(str: string, ...substitutions: Array<unknown>): string;
+declare const STATE_WILD_CARD = "*";
+type TStateWildCard = typeof STATE_WILD_CARD;
+type TStateMachine<S extends string, A extends string> = {
+    initial: S;
+    states: Partial<{
+        [key in S & TStateWildCard]: {
+            [key in A]?: S | [
+                S,
+                (payload?: any) => boolean
+            ];
+        };
+    }>;
+};
+declare function StateMachine<S extends string, A extends string>(machine: TStateMachine<S, A>): {
+    getState: () => S;
+    transition: (action: A, payload?: any) => void;
+};
+declare namespace tinyState {
+    function createTinyState<S>(initialValue: S | (() => S)): TinyState<S>;
+    type TinyState<S> = () => [
+        value: S,
+        setValue: (next: S | ((prev: S) => S)) => void,
+        resetValue: () => void
+    ];
+}
+export { createCache as cache, CacheApi, BusType, TinyState, isNullish, isNotNullish, asArray, callEach, hasOwnProperty, isPromise, optionalFunctionValue, _default as assign, defaultTo, invariant, StringObject, isStringValue, bindNot, either, isBoolean, last, deferThrow, bus, seq, genSeq, isFunction, mapFirst, greaterThan, longerThan, isNumeric, isNotNumeric, isObject, lengthEquals, lengthNotEquals, numberEquals, numberNotEquals, isNull, isNotNull, isUndefined, isNotUndefined, isArray, isNotArray, isEmpty, isNotEmpty, isPositive, text, TStateMachine, StateMachine, tinyState };
 export type { DropFirst, Stringable, CB, ValueOf };
 //# sourceMappingURL=vest-utils.d.ts.map

package/types/vest-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vest-utils.d.ts","sourceRoot":"","sources":["../src/vest-utils.ts","../src/bindNot.ts","../src/isNumeric.ts","../src/numberEquals.ts","../src/lengthEquals.ts","../src/greaterThan.ts","../src/longerThan.ts","../src/cache.ts","../src/isNull.ts","../src/isUndefined.ts","../src/isNullish.ts","../src/asArray.ts","../src/isFunction.ts","../src/optionalFunctionValue.ts","../src/defaultTo.ts","../src/isArrayValue.ts","../src/last.ts","../src/nestedArray.ts","../src/utilityTypes.ts","../src/callEach.ts","../src/hasOwnProperty.ts","../src/isPromise.ts","../src/assign.ts","../src/invariant.ts","../src/isStringValue.ts","../src/either.ts","../src/isBooleanValue.ts","../src/deferThrow.ts","../src/bus.ts","../src/seq.ts","../src/mapFirst.ts","../src/isEmpty.ts","../src/isPositive.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,ggBAA8B,CAAc;AAgCnD,YAAY,sCAAa,CAAqB"}
+{"version":3,"file":"vest-utils.d.ts","sourceRoot":"","sources":["../src/vest-utils.ts","../src/bindNot.ts","../src/isNumeric.ts","../src/numberEquals.ts","../src/lengthEquals.ts","../src/greaterThan.ts","../src/longerThan.ts","../src/cache.ts","../src/utilityTypes.ts","../src/bus.ts","../src/isFunction.ts","../src/optionalFunctionValue.ts","../src/tinyState.ts","../src/isNull.ts","../src/isUndefined.ts","../src/isNullish.ts","../src/asArray.ts","../src/callEach.ts","../src/hasOwnProperty.ts","../src/isPromise.ts","../src/assign.ts","../src/defaultTo.ts","../src/invariant.ts","../src/isStringValue.ts","../src/either.ts","../src/isBooleanValue.ts","../src/last.ts","../src/deferThrow.ts","../src/seq.ts","../src/mapFirst.ts","../src/valueIsObject.ts","../src/isArrayValue.ts","../src/isEmpty.ts","../src/isPositive.ts","../src/text.ts","../src/SimpleStateMachine.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,+jBAA8B,CAAc;AAqCnD,YAAY,sCAAa,CAAqB"}

package/src/__tests__/bindNot.test.ts

@@ -1,37 +0,0 @@
-import { bindNot } from 'vest-utils';
-
-describe('bindNot', () => {
-  it('Should return return a function', () => {
-    expect(typeof bindNot(jest.fn())).toBe('function');
-  });
-
-  test('calling returned function runs accepted function', () => {
-    const fn = jest.fn();
-
-    expect(fn).not.toHaveBeenCalled();
-    const not = bindNot(fn);
-    expect(fn).not.toHaveBeenCalled();
-    not();
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('Should pass arguments to accepted function', () => {
-    const fn = jest.fn();
-
-    const not = bindNot(fn);
-    not(1, 2, 3, 4);
-    expect(fn).toHaveBeenCalledWith(1, 2, 3, 4);
-  });
-
-  it('Should return the boolean negation of the original function', () => {
-    expect(bindNot(() => true)()).toBe(false);
-    expect(bindNot(() => false)()).toBe(true);
-    expect(bindNot(() => 'string')()).toBe(false);
-    expect(bindNot(() => [])()).toBe(false);
-    expect(bindNot(() => '')()).toBe(true);
-    expect(bindNot(() => 0)()).toBe(true);
-    expect(bindNot(() => NaN)()).toBe(true);
-    expect(bindNot(() => null)()).toBe(true);
-    expect(bindNot(() => undefined)()).toBe(true);
-  });
-});