varstor 0.6.64 → 0.6.66

package/src/index.ts

@@ -1,3 +1,18 @@
+import {
+  type IVarstor,
+  type IState,
+  type IStateUpdatePieces,
+  type IStatePendingChanges,
+  type IStorageFunctions,
+  type INamespace,
+  type IStateDefault,
+  type IComputeFunction,
+  type IValue,
+  type IStateChanges,
+  type IStateActions,
+  type IStateListener,
+} from "./types.d";
+
 import storageUtils from "./storage";
 
 import {
@@ -11,6 +26,7 @@ import {
   recreateStructure,
   forEach,
   uid,
+  isAsyncFunction,
 } from "./helpers";
 
 import { addStateActions } from "./actions";
@@ -25,7 +41,8 @@ import {
 } from "./listeners";
 
 export const STATE = {} as IState;
-const WAITING_CHANGES = {} as IStateUpdatePieces;
+const STATE_CHANGED_PIECES = {} as IStateUpdatePieces;
+const STATE_PENDING_CHANGES = {} as IStatePendingChanges;
 const STORAGE = {} as IStorageFunctions;
 
 setStorageUtils(storageUtils);
@@ -46,10 +63,6 @@ async function addState(
     await STORAGE.UPDATE_STATE(values, storageType as string);
   }
 
-  if (!LISTENERS[namespace()]) {
-    LISTENERS[namespace()] = [];
-  }
-
   for (const key in initialState) {
     const fullKey = namespace(key);
     STATE[fullKey] = setupValue(
@@ -129,7 +142,7 @@ export async function joinStateChanges(changesPiece: IStateChanges) {
   for (const [
     updateId,
     { storageTypes, readyStorageTypes, changes },
-  ] of Object.entries(WAITING_CHANGES)) {
+  ] of Object.entries(STATE_CHANGED_PIECES)) {
     if (changesPiece[updateId]) {
       const storageType = changesPiece[updateId].newValue;
       readyStorageTypes[storageType] = true;
@@ -145,7 +158,7 @@ export async function joinStateChanges(changesPiece: IStateChanges) {
         }
       }
 
-      delete WAITING_CHANGES[updateId];
+      delete STATE_CHANGED_PIECES[updateId];
 
       await onStateChange(changes);
     }
@@ -226,13 +239,13 @@ export function getState(namespace: INamespace, arg: string) {
     return createStore(arg);
   }
 
-  return recreateStructure(getValues(namespace));
+  return recreateStructure(getValues(namespace)) as Record<string, any>;
 }
 
 export async function setState(
   namespace: INamespace,
   changes: Record<string, unknown>,
-): Promise<unknown> {
+): Promise<IVarstor> {
   const storageChanges: Record<string, any> = {};
   const updateId = uid();
   const storageTypes = {} as Record<string, boolean>;
@@ -254,7 +267,7 @@ export async function setState(
     storageChanges[storageType!][fullKey] = v;
   });
 
-  WAITING_CHANGES[updateId] = {
+  STATE_CHANGED_PIECES[updateId] = {
     storageTypes,
     readyStorageTypes: {},
     changes: {},
@@ -284,27 +297,51 @@ async function setValues(
 }
 
 export async function resetState(namespace: INamespace, keys?: string[]) {
+  return setState(namespace, getDefaultValues(namespace, keys));
+}
+
+function getDefaultValues(namespace: INamespace, keys?: string[]) {
   const namespaceState = getNamespaceState(namespace);
 
-  await setState(
-    namespace,
-    map(
-      keys
-        ? filter(namespaceState, (k, { key }) => keys.includes(key!))
-        : namespaceState,
-      (k, { key, defaultValue }) => [key, defaultValue],
-    ) as Record<string, any>,
-  );
+  return map(
+    keys
+      ? filter(namespaceState, (k, { key }) => keys.includes(key!))
+      : namespaceState,
+    (k, { key, defaultValue }) => [key, defaultValue],
+  ) as Record<string, any>;
+}
 
-  return createStore(namespace());
+export function createPendingChanges(namespace: INamespace) {
+  const flush = () => {
+    const changes = STATE_PENDING_CHANGES[namespace()];
+    STATE_PENDING_CHANGES[namespace()] = {};
+    return changes;
+  };
+
+  return {
+    add: (changes: Record<string, any>) =>
+      Object.assign(STATE_PENDING_CHANGES[namespace()], changes),
+    reset: (keys: string[]) =>
+      Object.assign(
+        STATE_PENDING_CHANGES[namespace()],
+        getDefaultValues(namespace, keys),
+      ),
+    get: () => STATE_PENDING_CHANGES[namespace()],
+    flush,
+    commit: () => setState(namespace, flush()),
+  };
 }
 
-function main(namespace: INamespace): any {
+function main(namespace?: INamespace): any {
   if (!arguments[1] || isString(arguments[1])) {
     return getState.apply(null, arguments as unknown as [INamespace, string]);
   }
 
-  if (isArray(arguments[1])) {
+  if (
+    isArray(arguments[1]) ||
+    isFunction(arguments[1]) ||
+    isAsyncFunction(arguments[1])
+  ) {
     return addStateListener.apply(
       null,
       arguments as unknown as [INamespace, string[], () => {}],
@@ -327,21 +364,29 @@ function addNamespace(namespace: string, str: string) {
   return `${namespace}${(isString(str) && NAMESPACE_DELIMITER) || ""}${str || ""}`;
 }
 
-export function createStore(_namespace: string) {
+export function createStore(_namespace: string): IVarstor {
   const namespace = ((key: string) =>
     addNamespace(_namespace, key)) as INamespace;
 
+  if (!STATE_PENDING_CHANGES[namespace()]) {
+    STATE_PENDING_CHANGES[namespace()] = {};
+  }
+
+  if (!LISTENERS[namespace()]) {
+    LISTENERS[namespace()] = [];
+  }
+
   return Object.assign(main.bind(null, namespace), {
     add: (state: IStateDefault) => addState(namespace, state, false),
     addPersistent: (state: IStateDefault) => addState(namespace, state, true),
-    get: (newNamespace: string) => getState(namespace, newNamespace),
-    set: async (changes: Record<string, unknown>) =>
-      await setState(namespace, changes),
+    get: (newNamespace?: string) => getState(namespace, newNamespace!),
+    set: (changes: Record<string, unknown>) => setState(namespace, changes),
     reset: (keys: string[]) => resetState(namespace, keys),
-    onChange: (keys: string[], cb: () => {}) =>
-      addStateListener(namespace, keys, cb),
-    removeListener: (keys: string[], cb: () => {}) =>
-      removeStateListener(namespace, keys, cb),
+    changes: createPendingChanges(namespace),
+    onChange: (keys: string[] | IStateListener, cb?: IStateListener) =>
+      addStateListener(namespace, keys, cb!),
+    removeListener: (keys: string[] | IStateListener, cb?: IStateListener) =>
+      removeStateListener(namespace, keys, cb!),
     actions: (actions: IStateActions) => addStateActions(namespace, actions),
     setStorageUtils,
     joinStateChanges,

package/src/listeners.ts

@@ -1,4 +1,12 @@
-import { STATE, getValues, createStore } from ".";
+import {
+  type INamespace,
+  type IStateListeners,
+  type IStateChanges,
+  type IStateListener,
+  type IValue,
+} from "./types";
+
+import { STATE, createStore } from ".";
 import { NAMESPACE_DELIMITER } from "./constants";
 import { map, isFunction, isAsyncFunction } from "./helpers";
 
@@ -6,14 +14,13 @@ export const LISTENERS = {} as IStateListeners;
 
 export async function runStateChangeListeners(realChanges: IStateChanges) {
   if (Object.keys(realChanges).length) {
-    const { namespace } =
-      STATE[Object.keys(realChanges)[0] as keyof typeof STATE];
-    const stateValues = getValues(namespace);
-
-    for (let [changeKey, change] of Object.entries(realChanges)) {
+    const { namespace } = STATE[
+      Object.keys(realChanges)[0] as keyof typeof STATE
+    ] as IValue;
+    for (const [changeKey] of Object.entries(realChanges)) {
       const { listeners, key } = STATE[changeKey];
       for (const cb of listeners!) {
-        const fn = cb.bind(null, [key], stateValues, change);
+        const fn = cb.bind(null, [key!], createStore(namespace()));
         if (isAsyncFunction(cb)) {
           await fn();
         } else {
@@ -28,15 +35,7 @@ export async function runStateChangeListeners(realChanges: IStateChanges) {
     ) as string[];
 
     for (const cb of LISTENERS[namespace()]) {
-      const fn = cb.bind(
-        null,
-        readableKeys,
-        stateValues,
-        map(realChanges, (k, v) => [
-          k.slice(namespaceLength),
-          v,
-        ]) as IStateChanges,
-      );
+      const fn = cb.bind(null, readableKeys, createStore(namespace()));
       if (isAsyncFunction(cb)) {
         await fn();
       } else {
@@ -49,7 +48,7 @@ export async function runStateChangeListeners(realChanges: IStateChanges) {
 export function addStateListener(
   namespace: INamespace,
   observables: string[] | IStateListener,
-  cb: () => {},
+  cb: IStateListener,
 ) {
   if (isFunction(observables) || isAsyncFunction(observables)) {
     LISTENERS[namespace()].push(observables as IStateListener);
@@ -66,7 +65,7 @@ export function addStateListener(
 export function removeStateListener(
   namespace: INamespace,
   observables: string[] | IStateListener,
-  removeCb: () => {},
+  removeCb: IStateListener,
 ) {
   if (isFunction(observables) || isAsyncFunction(observables)) {
     const removeIdx = LISTENERS[namespace()].findIndex(
@@ -78,8 +77,8 @@ export function removeStateListener(
 
   (observables as string[]).forEach((key) => {
     const listeners = STATE[namespace(key)].listeners;
-    const removeIdx = listeners?.findIndex((cb) => cb === removeCb) as number;
-    listeners?.splice(removeIdx, 1);
+    const removeIdx = listeners?.findIndex((cb) => cb === removeCb);
+    listeners?.splice(removeIdx!, 1);
   });
 
   return createStore(namespace());

package/src/storage.ts

@@ -1,3 +1,5 @@
+import { type IStateDefault } from "./types";
+
 async function updateFromLocalStorage(state: IStateDefault) {
   const stored = {} as IStateDefault;
   for (const key in state) {
@@ -29,7 +31,7 @@ async function setStorageValue(
   return false;
 }
 
-function removeStorageKey (type: string, key: string) {
+function removeStorageKey(type: string, key: string) {
   if (type) {
     localStorage.removeItem(key);
   }

package/src/types.d.ts

@@ -11,7 +11,7 @@ type IValue = {
   dependencies?: string[];
   dependants?: string[];
   storageType?: string;
-  listeners?: any[];
+  listeners?: IStateListener[];
   defaultValue?: any;
   namespace: INamespace;
 };
@@ -32,11 +32,7 @@ type IStorageFunctions = {
   REMOVE_KEY: (type: string, key: string) => void;
 };
 
-type IStateListener = (
-  changes: string[],
-  values: Record<string, any>,
-  data: IStateChanges,
-) => any;
+type IStateListener = (changes: string[], store: IStore) => void;
 
 type IStateListeners = Record<string, IStateListener[]>;
 
@@ -44,8 +40,39 @@ type IStateAction = (mutator: IStateMutator, args: any[]) => void;
 
 type IStateActions = Record<string, IStateAction>;
 
-type IStateUpdatePieces = Record<string, {
-  storageTypes: Record<string, boolean>;
-  readyStorageTypes: Record<string, boolean>;
-  changes: IStateChanges;
-}>;
+type IStateUpdatePieces = Record<
+  string,
+  {
+    storageTypes: Record<string, boolean>;
+    readyStorageTypes: Record<string, boolean>;
+    changes: IStateChanges;
+  }
+>;
+
+type IStatePendingChanges = Record<string, Record<string, any>>;
+
+type IStatePendingChangesFunctions = {
+  add: (changes: Record<string, any>) => Record<string, any>;
+  reset: (keys: string[]) => Record<string, any>;
+  get: () => Record<string, any>;
+  flush: () => Record<string, any>;
+  commit: () => Promise<unknown>;
+};
+
+export type IVarstor = ((namespace?: INamespace) => any) & {
+  add: (state: IStateDefault) => Promise<IVarstor>;
+  addPersistent: (state: IStateDefault) => Promise<IVarstor>;
+  get: (newNamespace?: string) => IVarstor | Record<string, any>;
+  set: (changes: Record<string, unknown>) => Promise<IVarstor>;
+  reset: (keys: string[]) => Promise<IVarstor>;
+  changes: IStatePendingChangesFunctions;
+  onChange: (keys: string[] | IStateListener, cb?: IStateListener) => IVarstor;
+  removeListener: (
+    keys: string[] | IStateListener,
+    cb?: IStateListener,
+  ) => IVarstor;
+  actions: (actions: IStateActions) => IVarstor;
+  setStorageUtils: (storageUtils: IStorageFunctions) => void;
+  joinStateChanges: (changesPiece: IStateChanges) => Promise<unknown>;
+  namespace: INamespace;
+};

package/src/webextension-storage.ts

@@ -1,5 +1,7 @@
 const browser = require("webextension-polyfill/dist/browser-polyfill.min");
 
+import { type IStateDefault } from "./types";
+
 export default {
   GET_TYPE: getStorageType,
   IS_AVAILABE: isStorageAvailable,

package/webpack.config.js

@@ -25,13 +25,17 @@ module.exports = (env) => {
         {
           test: /\.(ts|tsx)$/i,
           loader: "ts-loader",
-          exclude: ["/node_modules/"],
+          exclude: /node_modules|\.d\.ts$/,
+        },
+        {
+          test: /\.d\.ts$/,
+          loader: "ignore-loader",
         },
       ],
     },
 
     resolve: {
-      extensions: [".ts", ".js"],
+      extensions: [".ts", ".js", ".d.ts"],
     },
 
     devtool: false,