varstor 0.6.61 → 0.6.63

package/src/{webextension-storage.js → webextension-storage.ts}

@@ -4,26 +4,26 @@ export default {
   GET_TYPE: getStorageType,
   IS_AVAILABE: isStorageAvailable,
   UPDATE_STATE: updateStateFromStorage,
-  SET_VALUE: setStorageValue,
+  SET_VALUES: setStorageValue,
 };
 
-function getStorageType(isPersistent) {
+function getStorageType(isPersistent: boolean) {
   return (isBackgroundScript() && isPersistent && "local") || "session";
 }
 
-function isStorageAvailable(storageType) {
+function isStorageAvailable(storageType: string) {
   return (
     storageType === "local" ||
     (storageType === "session" && isSessionStorageSupport())
   );
 }
 
-async function updateStateFromStorage(state, type) {
+async function updateStateFromStorage(state: IStateDefault, type: string) {
   return Object.assign(state, await browser.storage[type].get());
 }
 
-async function setStorageValue(type, key, value) {
-  await browser.storage[type].set({ [key]: value });
+async function setStorageValue(type: string, changes: Record<string, any>) {
+  await browser.storage[type].set(changes);
   return true;
 }
 

package/src/{webextension.js → webextension.ts}

@@ -1,7 +1,10 @@
 const browser = require("webextension-polyfill/dist/browser-polyfill.min");
 
-import main from '.';
-import webextensionStorageUtils, { isBackgroundScript, isSessionStorageSupport } from './webextension-storage';
+import main from ".";
+import webextensionStorageUtils, {
+  isBackgroundScript,
+  isSessionStorageSupport,
+} from "./webextension-storage";
 
 const { onStateChange, setStorageUtils } = main;
 

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "strict": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "target": "esnext",
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "isolatedModules": true,
+    "rewriteRelativeImportExtensions": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "ignoreDeprecations": "6.0",
+    "types": ["webpack-env"]
+  },
+  "include": ["./src/**/*"],
+  "exclude": ["./node_modules"]
+}

package/webpack.config.js

@@ -3,8 +3,8 @@ const MinimizerPlugin = require("minimizer-webpack-plugin");
 module.exports = (env) => {
   const options = {
     entry: {
-      varstor: "./src/index.js",
-      "varstor-webextension": "./src/webextension.js",
+      varstor: "./src/index.ts",
+      "varstor-webextension": "./src/webextension.ts",
     },
     output: {
       filename: ({ chunk }) => `./${chunk.name}.js`,
@@ -20,6 +20,20 @@ module.exports = (env) => {
       colors: true,
     },
 
+    module: {
+      rules: [
+        {
+          test: /\.(ts|tsx)$/i,
+          loader: "ts-loader",
+          exclude: ["/node_modules/"],
+        },
+      ],
+    },
+
+    resolve: {
+      extensions: [".ts", ".js"],
+    },
+
     devtool: false,
   };
 

package/src/helpers.js

@@ -1,40 +0,0 @@
-const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
-const ARGUMENT_NAMES = /([^\s,]+)/g;
-
-export function isFunction(x) {
-  return typeof x === "function";
-}
-
-export function isObject(x) {
-  return Object.prototype.toString.call(x) === "[object Object]";
-}
-
-export function isString(x) {
-  return typeof x === "string";
-}
-
-export function isArray(x) {
-  return Array.isArray(x);
-}
-
-export function getParamNames(fn) {
-  const fnStr = fn.toString().replace(STRIP_COMMENTS, "").split("=>")[0];
-  const names = fnStr
-    .slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")"))
-    .match(ARGUMENT_NAMES);
-
-  if (names === null) {
-    return [];
-  }
-
-  return names;
-}
-
-export function getKeys(obj, key) {
-  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, v[key]]));
-}
-
-export function toCamelCase(str, delimiter) {
-  const strArr = str.split(delimiter);
-  return `${strArr[0]}${strArr.slice(1).reduce((a, c) => `${a}${c.charAt(0).toUpperCase()}${c.slice(1)}`, "")}`;
-}

package/src/index.js

@@ -1,283 +0,0 @@
-import storageUtils from './storage';
-
-import {
-  isArray, isFunction, isObject, isString,
-  getParamNames,
-  getKeys,
-} from './helpers';
-
-import {
-  addNamespace,
-  splitFullKey,
-  namespacify,
-  getByNamespace,
-} from "./namespace";
-
-import {
-  isValid
-} from './validation';
-
-const STATE = {};
-export const ACCESSORS = {};
-const COMPUTED_DEPENDENCIES = {};
-const COMPUTED_ARGUMENTS = {};
-
-const STORAGE = {
-  GET_TYPE: null,
-  IS_AVAILABE: null,
-  UPDATE_STATE: null,
-  SET_VALUE: null
-};
-
-setStorageUtils(storageUtils);
-
-async function addState (namespace, initialState, isPersistent) {
-  const storageType = STORAGE.GET_TYPE(isPersistent);
-  const defaultValues = Object.assign({}, initialState);
-  const namespacedValues = namespacify(namespace(), initialState);
-
-  if (STORAGE.IS_AVAILABE(storageType)) {
-    await STORAGE.UPDATE_STATE(namespacedValues, storageType);
-  }
-
-  const accessors = {};
-  for (const key in initialState) {
-    isValid.Defining(namespace(key));
-    accessors[namespace(key)] = setupValue(
-      namespace(key),
-      namespacedValues[namespace(key)],
-      defaultValues[key],
-      storageType,
-    );
-  }
-
-  Object.assign(ACCESSORS, accessors);
-  return createStore(namespace());
-}
-
-function setupValue (key, value, defaultValue, storageType) {
-  const isComputedValue = isFunction(value);
-
-  if (isComputedValue) {
-    setupDependencies(key, value);
-  }
-
-  STATE[key] = {
-    value: isComputedValue ? value.apply(null, getArguments(key)) : value,
-    computeFn: value,
-    listeners: [],
-    defaultValue,
-  };
-
-  return createAccessor(key, storageType);
-}
-
-function setupDependencies(computedValueName, computeFn) {
-  const [, namespace] = splitFullKey(computedValueName);
-  const paramNames = getParamNames(computeFn).map((name) => addNamespace(namespace, name));
-  COMPUTED_ARGUMENTS[computedValueName] = paramNames;
-
-  paramNames.forEach((param) => {
-    if (COMPUTED_DEPENDENCIES[param]) {
-      COMPUTED_DEPENDENCIES[param].push(computedValueName);
-    } else {
-      COMPUTED_DEPENDENCIES[param] = [computedValueName];
-    }
-  });
-}
-
-function getArguments(computedName) {
-  const values = getNamespaceValues(computedName);
-  
-  return COMPUTED_ARGUMENTS[computedName]
-    .map((name) => values[splitFullKey(name)[0]])
-    .concat(values);
-}
-
-function createAccessor(key, storageType) {
-  const accessor = () => STATE[key].value;
-
-  Object.assign(accessor, {
-    valueOf: () => STATE[key].value,
-    toString: () => STATE[key].value,
-    set: async (value) => await setValue(key, value, storageType),
-    onChange: (cb) => STATE[key].listeners.push(cb),
-    removeListener: (removeCb) =>
-      (STATE[key].listeners = STATE[key].listeners.filter(
-        (cb) => cb !== removeCb,
-      )),
-    reset: () => setValue(key, STATE[key].defaultValue, storageType),
-  });
-
-  return new Proxy(accessor, {
-    get: (target, prop) => {
-      if (Object.keys(accessor).includes(prop)) {
-        return target[prop];
-      }
-
-      return STATE[key].value[prop];
-    },
-  });
-}
-
-async function setValue (key, value, storageType) {
-  if (STORAGE.IS_AVAILABE(storageType)) {
-    const isAutoUpdate = await STORAGE.SET_VALUE(storageType, key, value);
-    if (isAutoUpdate) {
-      return;
-    }
-  }
-
-  onStateChange({ [key]: { newValue: value } });
-}
-
-function onStateChange (changes) {
-  const realChanges = {};
-
-  for (const key in changes) {
-    const prevValue = STATE[key].value;
-    const newValue = changes[key].newValue;
-
-    if (prevValue !== newValue) {
-      STATE[key].value = newValue;
-      realChanges[key] = { newValue, prevValue };
-
-      updateDependencies(key, realChanges);
-    }
-  }
-
-  for (const key in realChanges) {
-    STATE[key].listeners.forEach(async (cb) => await cb(STATE[key].value, getNamespaceValues(key), realChanges[key]));
-  }
-}
-
-function updateDependencies (key, realChanges) {
-  const computedDependencies = COMPUTED_DEPENDENCIES[key];
-  if (computedDependencies) {
-    computedDependencies.forEach((name) => {
-      const prevValue = STATE[name].value;
-      const newValue = STATE[name].computeFn.apply(null, getArguments(name));
-      if (prevValue !== newValue) {
-        STATE[name].value = newValue;
-        realChanges[name] = { newValue, prevValue };
-        updateDependencies(name, realChanges);
-      }
-    });
-  }
-}
-
-function getState(namespace, arg) {
-  if (isString(arg)) {
-    return createStore(arg);
-  }
-
-  if (isFunction(arg)) {
-    return getNamespaceAccessors(namespace(""), arg);
-  }
-
-  return getNamespaceValues(namespace(""));
-}
-
-function getNamespaceValues(namespace) {
-  return recreateStructure(getKeys(getByNamespace(namespace, STATE), "value"));
-}
-
-function getNamespaceAccessors (namespace, cb) {
-  const accessors = getByNamespace(namespace, ACCESSORS);
-  return cb.call(null, accessors, createStore(namespace()));
-}
-
-async function setState (namespace, changes) {
-  const noKeys = !Object.keys(changes).length;
-
-  if (noKeys) {
-    resetAllState();
-  } else {
-    for (const [k,v] of Object.entries(changes)) {
-      isValid.Setting(namespace(k));
-      await ACCESSORS[namespace(k)].set(v);
-    };
-  }
-
-  return createStore(namespace());
-}
-
-function resetAllState (namespace) {
-  Object.entries(ACCESSORS)
-    .filter(([k]) => k.startsWith(namespace()))
-    .forEach((k, { reset }) => reset());
-
-  return createStore(namespace());
-}
-
-function addStateLitener (namespace, observables, cb) {
-  observables.forEach((key) => ACCESSORS[namespace(key)].onChange(cb));
-
-  return createStore(namespace());
-}
-
-function removeStateListener(namespace, observables, cb) {
-  observables.forEach((key) =>
-    ACCESSORS[namespace(key)].removeListener(cb),
-  );
-
-  return createStore(namespace());
-}
-
-function recreateStructure (value) {
-  let newValue = value;
-
-  if (isArray(value)) {
-    newValue = [];
-    value.forEach((v) => newValue.push(recreateStructure(v)));
-    return newValue;
-  }
-
-  if (isObject(value)) {
-    newValue = {};
-    for (let key in value) {
-      newValue[key] = recreateStructure(value[key]);
-    }
-    return newValue;
-  }
-
-  return newValue;
-}
-
-function main () {
-  const arg1 = arguments[1];
-
-  if (!arg1 || isFunction(arg1) || isString(arg1)) {
-    return getState.apply(null, arguments);
-  }
-
-  if (Array.isArray(arg1)) {
-    return addStateLitener.apply(null, arguments);
-  }
-
-  if (isObject(arg1)) {
-    return setState.apply(null, arguments);
-  }
-}
-
-function setStorageUtils(storageUtils) {
-  Object.assign(STORAGE, storageUtils);
-}
-
-function createStore (_namespace) {
-  const namespace = (key) => addNamespace(_namespace, key);
-
-  return Object.assign(main.bind(null, namespace), {
-    add: (state) => addState(namespace, state, false),
-    addPersistent: (state) => addState(namespace, state, true),
-    get: (arg) => getState(namespace, arg),
-    set: async (changes) => await setState(namespace, changes),
-    resetAll: () => resetAllState(namespace),
-    onChange: (keys, cb) => addStateLitener(namespace, keys, cb),
-    removeListener: (keys, cb) => removeStateListener(namespace, keys, cb),
-    setStorageUtils,
-    onStateChange,
-  });
-}
-
-export default createStore("");

package/src/namespace.js

@@ -1,35 +0,0 @@
-import {
-  getKeys, isString, toCamelCase
-} from './helpers';
-
-const NAMESPACE_DELIMITER = "::";
-
-export function addNamespace(namespace, str) {
-  return `${namespace}${isString(str) && NAMESPACE_DELIMITER || ""}${str || ""}`;
-}
-
-export function splitFullKey (str) {
-  const segments = str.split(NAMESPACE_DELIMITER);
-
-  return [
-    segments.slice(-1)[0],
-    segments.slice(0, -1).join(NAMESPACE_DELIMITER),
-  ];
-}
-
-export function getByNamespace(str, obj) {
-  const namespace = splitFullKey(str)[1] + NAMESPACE_DELIMITER;
-
-  return Object.fromEntries(
-    Object.entries(obj)
-      .filter(([k, v]) => k.startsWith(namespace))
-      .map(([k, v]) => [k.slice(namespace.length), v]),
-  );
-}
-
-export function namespacify (namespace, obj) {
-  return Object.fromEntries(
-    Object.entries(obj)
-      .map(([k,v]) => [addNamespace(namespace, k), v]
-  ));
-}

package/src/storage.js

@@ -1,31 +0,0 @@
-function updateFromLocalStorage(state) {
-  const stored = {};
-  for (const key in state) {
-    const value = localStorage.getItem(key);
-    if (value !== null) {
-      stored[key] = value;
-    }
-  }
-
-  return Object.assign(state, stored);
-}
-
-function getStorageType(isPersistent) {
-  return isPersistent && "localStorage";
-}
-
-function isStorageAvailable(storageType) {
-  return storageType;
-}
-
-async function setStorageValue(storageType, key, value) {
-  await window.localStorage.setItem(key, value);
-  return false;
-}
-
-export default {
-  GET_TYPE: getStorageType,
-  IS_AVAILABE: isStorageAvailable,
-  UPDATE_STATE: updateFromLocalStorage,
-  SET_VALUE: setStorageValue,
-};