vest-utils 0.1.0-dev-c4ba9b → 0.1.0-dev-405df5

package/src/tinyState.ts

@@ -0,0 +1,23 @@
+import optionalFunctionValue from 'optionalFunctionValue';
+
+export function createTinyState<S>(initialValue: S | (() => S)): TinyState<S> {
+  let value: S;
+
+  resetValue();
+
+  return () => [value, setValue, resetValue];
+
+  function setValue(nextValue: S | ((currentValue: S) => S)) {
+    value = optionalFunctionValue(nextValue, value);
+  }
+
+  function resetValue() {
+    setValue(optionalFunctionValue(initialValue));
+  }
+}
+
+export type TinyState<S> = () => [
+  value: S,
+  setValue: (next: S | ((prev: S) => S)) => void,
+  resetValue: () => void
+];

package/src/vest-utils.ts

@@ -1,4 +1,6 @@
-export { default as cache } from 'cache';
+export { default as cache, CacheApi } from 'cache';
+export { BusType } from 'bus';
+export { TinyState } from 'tinyState';
 export { isNullish, isNotNullish } from 'isNullish';
 export * as nestedArray from 'nestedArray';
 export { default as asArray } from 'asArray';
@@ -16,7 +18,7 @@ export { default as isBoolean } from 'isBooleanValue';
 export { default as last } from 'last';
 export { default as deferThrow } from 'deferThrow';
 export * as bus from 'bus';
-export { default as seq } from 'seq';
+export { default as seq, genSeq } from 'seq';
 export { default as isFunction } from 'isFunction';
 export { default as mapFirst } from 'mapFirst';
 export { greaterThan } from 'greaterThan';
@@ -29,6 +31,7 @@ export { isUndefined, isNotUndefined } from 'isUndefined';
 export { isArray, isNotArray } from 'isArrayValue';
 export { isEmpty, isNotEmpty } from 'isEmpty';
 export { isPositive } from 'isPositive';
+export * as tinyState from 'tinyState';
 
 export type { DropFirst } from 'utilityTypes';
 export type { Stringable } from 'utilityTypes';

package/tsconfig.json

@@ -3,8 +3,8 @@
   "rootDir": ".",
   "compilerOptions": {
     "baseUrl": ".",
-    "declarationMap": true,
     "declarationDir": "./types",
+    "declarationMap": true,
     "outDir": "./dist",
     "paths": {
       "asArray": ["src/asArray.ts"],
@@ -39,6 +39,7 @@
       "numberEquals": ["src/numberEquals.ts"],
       "optionalFunctionValue": ["src/optionalFunctionValue.ts"],
       "seq": ["src/seq.ts"],
+      "tinyState": ["src/tinyState.ts"],
       "utilityTypes": ["src/utilityTypes.ts"],
       "vest-utils": ["src/vest-utils.ts"]
     }

package/types/vest-utils.d.ts

@@ -1,11 +1,41 @@
 /**
  * Creates a cache function
  */
-declare function createCache(maxSize?: number): {
-    <T>(deps: unknown[], cacheAction: (...args: unknown[]) => T): T;
-    get(deps: unknown[]): any;
+declare function createCache<T = unknown>(maxSize?: number): {
+    (deps: unknown[], cacheAction: (...args: unknown[]) => T): T;
+    get(deps: unknown[]): [
+        unknown[],
+        T
+    ] | null;
     invalidate(item: any): void;
 };
+type CacheApi<T = unknown> = {
+    (deps: unknown[], cacheAction: (...args: unknown[]) => T): T;
+    get(deps: unknown[]): [
+        unknown[],
+        T
+    ] | null;
+    invalidate(item: any): void;
+};
+type DropFirst<T extends unknown[]> = T extends [
+    unknown,
+    ...infer U
+] ? U : never;
+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 namespace nestedArray {
@@ -20,13 +50,6 @@ declare namespace nestedArray {
     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
-] ? U : never;
-type Stringable = string | ((...args: any[]) => string);
-type CB = (...args: any[]) => any;
-type ValueOf<T> = T[keyof T];
 declare function callEach(arr: CB[]): void;
 /**
  * A safe hasOwnProperty access
@@ -60,18 +83,20 @@ 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.
  */
 declare const seq: () => string;
+declare function genSeq(namespace?: string): () => string;
 declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
 declare function mapFirst<T>(array: T[], callback: (item: T, breakout: (conditional: boolean, value: unknown) => void, index: number) => unknown): any;
 declare function greaterThan(value: number | string, gt: number | string): boolean;
@@ -94,6 +119,14 @@ 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, isNullish, isNotNullish, nestedArray, asArray, callEach, hasOwnProperty, isPromise, optionalFunctionValue, _default as assign, defaultTo, invariant, StringObject, isStringValue, bindNot, either, isBoolean, last, deferThrow, bus, seq, isFunction, mapFirst, greaterThan, longerThan, isNumeric, isNotNumeric, lengthEquals, lengthNotEquals, numberEquals, numberNotEquals, isNull, isNotNull, isUndefined, isNotUndefined, isArray, isNotArray, isEmpty, isNotEmpty, isPositive };
+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, 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, 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,8eAAoB,CAAc;AAgCzC,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/defaultTo.ts","../src/isArrayValue.ts","../src/last.ts","../src/nestedArray.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/seq.ts","../src/mapFirst.ts","../src/isEmpty.ts","../src/isPositive.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,+hBAA8B,CAAc;AAmCnD,YAAY,sCAAa,CAAqB"}