varstor 0.6.63 → 0.6.65

package/src/listeners.ts

@@ -1,6 +1,6 @@
-import { STATE, getValues, createStore } from ".";
+import { STATE, createStore } from ".";
 import { NAMESPACE_DELIMITER } from "./constants";
-import { map, isFunction } from "./helpers";
+import { map, isFunction, isAsyncFunction } from "./helpers";
 
 export const LISTENERS = {} as IStateListeners;
 
@@ -8,28 +8,34 @@ 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)) {
+    for (const [changeKey] of Object.entries(realChanges)) {
       const { listeners, key } = STATE[changeKey];
       for (const cb of listeners!) {
-        await cb([key], stateValues, change);
+        const fn = cb.bind(null, [key], createStore(namespace()));
+        if (isAsyncFunction(cb)) {
+          await fn();
+        } else {
+          fn();
+        }
       }
     }
 
+    const namespaceLength = `${namespace()}${NAMESPACE_DELIMITER}`.length;
     const readableKeys = map(realChanges, (k) =>
-      k.slice(NAMESPACE_DELIMITER.length),
+      k.slice(namespaceLength),
     ) as string[];
 
     for (const cb of LISTENERS[namespace()]) {
-      await cb(
+      const fn = cb.bind(
+        null,
         readableKeys,
-        stateValues,
-        map(realChanges, (k, v) => [
-          k.slice(NAMESPACE_DELIMITER.length),
-          v,
-        ]) as IStateChanges,
+        createStore(namespace())
       );
+      if (isAsyncFunction(cb)) {
+        await fn();
+      } else {
+        fn();
+      }
     }
   }
 }
@@ -39,7 +45,7 @@ export function addStateListener(
   observables: string[] | IStateListener,
   cb: () => {},
 ) {
-  if (isFunction(observables)) {
+  if (isFunction(observables) || isAsyncFunction(observables)) {
     LISTENERS[namespace()].push(observables as IStateListener);
     return createStore(namespace());
   }
@@ -56,7 +62,7 @@ export function removeStateListener(
   observables: string[] | IStateListener,
   removeCb: () => {},
 ) {
-  if (isFunction(observables)) {
+  if (isFunction(observables) || isAsyncFunction(observables)) {
     const removeIdx = LISTENERS[namespace()].findIndex(
       (cb) => cb === observables,
     );

package/src/storage.ts

@@ -29,9 +29,16 @@ async function setStorageValue(
   return false;
 }
 
+function removeStorageKey (type: string, key: string) {
+  if (type) {
+    localStorage.removeItem(key);
+  }
+}
+
 export default {
   GET_TYPE: getStorageType,
   IS_AVAILABE: isStorageAvailable,
   UPDATE_STATE: updateFromLocalStorage,
   SET_VALUES: setStorageValue,
+  REMOVE_KEY: removeStorageKey,
 };

package/src/types.d.ts

@@ -29,16 +29,24 @@ type IStorageFunctions = {
   IS_AVAILABE: (type: string) => boolean;
   UPDATE_STATE: (state: IStateDefault, type: string) => IStateDefault;
   SET_VALUES: (type: string, changes: Record<string, any>) => Promise<boolean>;
+  REMOVE_KEY: (type: string, key: string) => void;
 };
 
 type IStateListener = (
   changes: string[],
-  values: Record<string, any>,
-  data: IStateChanges,
-) => {};
+  store: Record<string, any>,
+) => any;
 
 type IStateListeners = Record<string, IStateListener[]>;
 
 type IStateAction = (mutator: IStateMutator, args: any[]) => void;
 
-type IStateActions = Record<string, IStateAction>;
+type IStateActions = Record<string, IStateAction>;
+
+type IStateUpdatePieces = Record<string, {
+  storageTypes: Record<string, boolean>;
+  readyStorageTypes: Record<string, boolean>;
+  changes: IStateChanges;
+}>;
+
+type IStatePendingChanges = Record<string, Record<string, any>>;

package/src/webextension-storage.ts

@@ -5,6 +5,7 @@ export default {
   IS_AVAILABE: isStorageAvailable,
   UPDATE_STATE: updateStateFromStorage,
   SET_VALUES: setStorageValue,
+  REMOVE_KEY: removeStorageKey,
 };
 
 function getStorageType(isPersistent: boolean) {
@@ -27,6 +28,12 @@ async function setStorageValue(type: string, changes: Record<string, any>) {
   return true;
 }
 
+async function removeStorageKey(type: string, key: string) {
+  if (type) {
+    await browser.storage[type].remove(key);
+  }
+}
+
 export function isSessionStorageSupport() {
   return !!browser.storage.session;
 }

package/src/webextension.ts

@@ -6,12 +6,12 @@ import webextensionStorageUtils, {
   isSessionStorageSupport,
 } from "./webextension-storage";
 
-const { onStateChange, setStorageUtils } = main;
+const { joinStateChanges, setStorageUtils } = main;
 
 if (isBackgroundScript()) {
-  browser.storage.local.onChanged.addListener(onStateChange);
+  browser.storage.local.onChanged.addListener(joinStateChanges);
   isSessionStorageSupport() &&
-    browser.storage.session.onChanged.addListener(onStateChange);
+    browser.storage.session.onChanged.addListener(joinStateChanges);
 }
 
 setStorageUtils(webextensionStorageUtils);

package/src/validation.ts

@@ -1,31 +0,0 @@
-import { STATE } from ".";
-import { NAMESPACE_DELIMITER } from "./constants";
-
-function splitFullKey(fullKey: string) {
-  const segments = fullKey.split(NAMESPACE_DELIMITER);
-  return [segments.slice(-1)[0], segments.join(NAMESPACE_DELIMITER)];
-}
-
-export const isValid = {
-  Setting: (fullKey: string) => {
-    if (!STATE[fullKey]) {
-      const [key, namespace] = splitFullKey(fullKey);
-      throw new Error(
-        `Setting "${key}" key in "${namespace}" namespace. DOES NOT EXIST`,
-      );
-    }
-
-    return true;
-  },
-
-  Defining: (fullKey: string) => {
-    if (STATE[fullKey]) {
-      const [key, namespace] = splitFullKey(fullKey);
-      throw new Error(
-        `Redefining "${key}" key in "${namespace}" namespace. ALREADY DEFINED`,
-      );
-    }
-
-    return true;
-  },
-};