varstor 0.6.61 → 0.6.63

package/dist/varstor.min.js

@@ -1,2 +1,2 @@
 /*! For license information please see varstor.min.js.LICENSE.txt */
-!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.Varstor=t():e.Varstor=t()}(this,()=>(()=>{"use strict";var e={"./src/helpers.js"(e,t,n){n.r(t),n.d(t,{getKeys:()=>l,getParamNames:()=>u,isArray:()=>a,isFunction:()=>i,isObject:()=>o,isString:()=>c,toCamelCase:()=>f});const r=/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm,s=/([^\s,]+)/g;function i(e){return"function"==typeof e}function o(e){return"[object Object]"===Object.prototype.toString.call(e)}function c(e){return"string"==typeof e}function a(e){return Array.isArray(e)}function u(e){const t=e.toString().replace(r,"").split("=>")[0],n=t.slice(t.indexOf("(")+1,t.indexOf(")")).match(s);return null===n?[]:n}function l(e,t){return Object.fromEntries(Object.entries(e).map(([e,n])=>[e,n[t]]))}function f(e,t){const n=e.split(t);return`${n[0]}${n.slice(1).reduce((e,t)=>`${e}${t.charAt(0).toUpperCase()}${t.slice(1)}`,"")}`}},"./src/index.js"(e,t,n){n.r(t),n.d(t,{ACCESSORS:()=>a,default:()=>V});var r=n("./src/storage.js"),s=n("./src/helpers.js"),i=n("./src/namespace.js"),o=n("./src/validation.js");const c={},a={},u={},l={},f={GET_TYPE:null,IS_AVAILABE:null,UPDATE_STATE:null,SET_VALUE:null};async function p(e,t,n){const r=f.GET_TYPE(n),s=Object.assign({},t),c=(0,i.namespacify)(e(),t);f.IS_AVAILABE(r)&&await f.UPDATE_STATE(c,r);const u={};for(const n in t)o.isValid.Defining(e(n)),u[e(n)]=d(e(n),c[e(n)],s[n],r);return Object.assign(a,u),w(e())}function d(e,t,n,r){const o=(0,s.isFunction)(t);return o&&function(e,t){const[,n]=(0,i.splitFullKey)(e),r=(0,s.getParamNames)(t).map(e=>(0,i.addNamespace)(n,e));l[e]=r,r.forEach(t=>{u[t]?u[t].push(e):u[t]=[e]})}(e,t),c[e]={value:o?t.apply(null,y(e)):t,computeFn:t,listeners:[],defaultValue:n},function(e,t){const n=()=>c[e].value;return Object.assign(n,{valueOf:()=>c[e].value,toString:()=>c[e].value,set:async n=>await g(e,n,t),onChange:t=>c[e].listeners.push(t),removeListener:t=>c[e].listeners=c[e].listeners.filter(e=>e!==t),reset:()=>g(e,c[e].defaultValue,t)}),new Proxy(n,{get:(t,r)=>Object.keys(n).includes(r)?t[r]:c[e].value[r]})}(e,r)}function y(e){const t=S(e);return l[e].map(e=>t[(0,i.splitFullKey)(e)[0]]).concat(t)}async function g(e,t,n){if(f.IS_AVAILABE(n)){if(await f.SET_VALUE(n,e,t))return}j({[e]:{newValue:t}})}function j(e){const t={};for(const n in e){const r=c[n].value,s=e[n].newValue;r!==s&&(c[n].value=s,t[n]={newValue:s,prevValue:r},m(n,t))}for(const e in t)c[e].listeners.forEach(async n=>await n(c[e].value,S(e),t[e]))}function m(e,t){const n=u[e];n&&n.forEach(e=>{const n=c[e].value,r=c[e].computeFn.apply(null,y(e));n!==r&&(c[e].value=r,t[e]={newValue:r,prevValue:n},m(e,t))})}function E(e,t){return(0,s.isString)(t)?w(t):(0,s.isFunction)(t)?function(e,t){const n=(0,i.getByNamespace)(e,a);return t.call(null,n,w(e()))}(e(""),t):S(e(""))}function S(e){return v((0,s.getKeys)((0,i.getByNamespace)(e,c),"value"))}async function O(e,t){if(!Object.keys(t).length)b();else for(const[n,r]of Object.entries(t))o.isValid.Setting(e(n)),await a[e(n)].set(r);return w(e())}function b(e){return Object.entries(a).filter(([t])=>t.startsWith(e())).forEach((e,{reset:t})=>t()),w(e())}function A(e,t,n){return t.forEach(t=>a[e(t)].onChange(n)),w(e())}function v(e){let t=e;if((0,s.isArray)(e))return t=[],e.forEach(e=>t.push(v(e))),t;if((0,s.isObject)(e)){t={};for(let n in e)t[n]=v(e[n]);return t}return t}function h(){const e=arguments[1];return!e||(0,s.isFunction)(e)||(0,s.isString)(e)?E.apply(null,arguments):Array.isArray(e)?A.apply(null,arguments):(0,s.isObject)(e)?O.apply(null,arguments):void 0}function T(e){Object.assign(f,e)}function w(e){const t=t=>(0,i.addNamespace)(e,t);return Object.assign(h.bind(null,t),{add:e=>p(t,e,!1),addPersistent:e=>p(t,e,!0),get:e=>E(t,e),set:async e=>await O(t,e),resetAll:()=>b(t),onChange:(e,n)=>A(t,e,n),removeListener:(e,n)=>function(e,t,n){return t.forEach(t=>a[e(t)].removeListener(n)),w(e())}(t,e,n),setStorageUtils:T,onStateChange:j})}T(r.default);const V=w("")},"./src/namespace.js"(e,t,n){n.r(t),n.d(t,{addNamespace:()=>i,getByNamespace:()=>c,namespacify:()=>a,splitFullKey:()=>o});var r=n("./src/helpers.js");const s="::";function i(e,t){return`${e}${(0,r.isString)(t)&&s||""}${t||""}`}function o(e){const t=e.split(s);return[t.slice(-1)[0],t.slice(0,-1).join(s)]}function c(e,t){const n=o(e)[1]+s;return Object.fromEntries(Object.entries(t).filter(([e,t])=>e.startsWith(n)).map(([e,t])=>[e.slice(n.length),t]))}function a(e,t){return Object.fromEntries(Object.entries(t).map(([t,n])=>[i(e,t),n]))}},"./src/storage.js"(e,t,n){n.r(t),n.d(t,{default:()=>r});const r={GET_TYPE:function(e){return e&&"localStorage"},IS_AVAILABE:function(e){return e},UPDATE_STATE:function(e){const t={};for(const n in e){const e=localStorage.getItem(n);null!==e&&(t[n]=e)}return Object.assign(e,t)},SET_VALUE:async function(e,t,n){return await window.localStorage.setItem(t,n),!1}}},"./src/validation.js"(e,t,n){n.r(t),n.d(t,{isValid:()=>i});var r=n("./src/index.js"),s=n("./src/namespace.js");const i={Setting:e=>{if(!r.ACCESSORS[e]){const[t,n]=(0,s.splitFullKey)(e);throw new Error(`Setting "${t}" key in "${n}" namespace. DOES NOT EXIST`)}return!0},Defining:e=>{if(r.ACCESSORS[e]){const[t,n]=(0,s.splitFullKey)(e);throw new Error(`Redefining "${t}" key in "${n}" namespace. ALREADY DEFINED`)}return!0}}}};const t={};function n(r){const s=t[r];if(void 0!==s)return s.exports;const i=t[r]={exports:{}};if(!(r in e)){delete t[r];const e=new Error("Cannot find module '"+r+"'");throw e.code="MODULE_NOT_FOUND",e}return e[r](i,i.exports,n),i.exports}n.d=(e,t)=>{if(Array.isArray(t))for(var r=0;r<t.length;){var s=t[r++],i=t[r++];n.o(e,s)?0===i&&r++:0===i?Object.defineProperty(e,s,{enumerable:!0,value:t[r++]}):Object.defineProperty(e,s,{enumerable:!0,get:i})}else for(var s in t)n.o(t,s)&&!n.o(e,s)&&Object.defineProperty(e,s,{enumerable:!0,get:t[s]})},n.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),n.r=e=>{Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};let r=n("./src/index.js");return r=r.default,r})());
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.Varstor=t():e.Varstor=t()}(this,()=>(()=>{"use strict";var e={"./src/actions.ts"(e,t,n){n.r(t),n.d(t,{addStateActions:()=>s});var r=n("./src/index.ts");function s(e,t){const n={get:r.getState.bind(null,e),set:r.setState.bind(null,e),reset:r.resetState.bind(null,e)};for(let[s,c]of Object.entries(t))r.STATE[e(s)]={key:s,namespace:e,value:c.bind(null,n),isAction:!0,listeners:[]}}},"./src/constants.ts"(e,t,n){n.r(t),n.d(t,{NAMESPACE_DELIMITER:()=>r});const r="::"},"./src/helpers.ts"(e,t,n){n.r(t),n.d(t,{filter:()=>p,forEach:()=>d,getParamNames:()=>l,isArray:()=>c,isFunction:()=>i,isObject:()=>a,isString:()=>o,map:()=>f,recreateStructure:()=>S});const r=/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm,s=/([^\s,]+)/g;function c(e){return"[object Array]"===u(e)}function o(e){return"[object String]"===u(e)}function i(e){return"[object Function]"===u(e)}function a(e){return"[object Object]"===u(e)}function u(e){return Object.prototype.toString.call(e)}function l(e){const t=e.toString().replace(r,"").split("=>")[0],n=t.slice(t.indexOf("(")+1,t.indexOf(")")).match(s);return null===n?[]:n}function f(e,t){const n=Object.entries(e).map(([e,n])=>t(e,n));return 2===n[0]?.length?Object.fromEntries(n):n}function d(e,t){Object.entries(e||{}).forEach(([e,n])=>t(e,n))}function p(e,t){return Object.fromEntries(Object.entries(e||{}).filter(([e,n])=>!0===t(e,n)))}function S(e){let t=e;if(c(e))return t=[],e.forEach(e=>t.push(S(e))),t;if(a(e)){t={};for(let n in e)t[n]=S(e[n]);return t}return t}},"./src/index.ts"(e,t,n){n.r(t),n.d(t,{STATE:()=>u,createStore:()=>h,default:()=>v,getState:()=>A,getValues:()=>S,resetState:()=>m,setState:()=>T,setupValue:()=>d});var r=n("./src/storage.ts"),s=n("./src/helpers.ts"),c=n("./src/actions.ts"),o=n("./src/constants.ts"),i=n("./src/validation.ts"),a=n("./src/listeners.ts");const u={},l={};async function f(e,t,n){const r=l.GET_TYPE(n),c=Object.assign({},t),o=(0,s.map)(t,(t,n)=>[e(t),n]);l.IS_AVAILABE(r)&&await l.UPDATE_STATE(o,r),a.LISTENERS[e()]||(a.LISTENERS[e()]=[]);for(const n in t){const t=e(n);i.isValid.Defining(t),u[t]=d(n,e,o[t],c[n],r)}return h(e())}function d(e,t,n,r,c){const o=t(e),i=(0,s.isFunction)(n),a=i?(0,s.getParamNames)(n):[];return a.forEach(e=>{const n=t(e);u[n]||(u[n]={dependants:[],dependencies:[],namespace:t,storageType:c}),u[n].dependants?.push(o)}),{key:e,fullKey:o,value:i?n.apply(null,E(a,t)):n,computeFn:i&&n,dependencies:a,dependants:[],listeners:[],defaultValue:r,storageType:c,namespace:t}}function p(e){return(0,s.filter)(u,(t,{key:n})=>t===e(n))}function S(e){return(0,s.map)(p(e),(e,{key:t,value:n})=>[t,n])}function E(e,t){const n=S(t);return e.map(e=>n[e])}async function g(e){const t={};for(const n in e){const r=u[n].value,s=e[n].newValue;r!==s?(t[n]={newValue:s,prevValue:r},u[n].value=s):t[n]={isSame:!0},y(n,e,t)}await(0,a.runStateChangeListeners)((0,s.filter)(t,(e,t)=>!t.isSame))}function y(e,t,n){u[e].dependants?.forEach(e=>{const{dependencies:r,namespace:s}=u[e];if(!function(e,t,n,r){return e.every(e=>{const s=t(e);return n.includes(s)&&r.includes(s)||!n.includes(s)})}(r,s,Object.keys(t),Object.keys(n))||n[e])return;const c=u[e].value,o=u[e].computeFn?.apply(null,E(r,s));c!==o&&(n[e]={newValue:o,prevValue:c},u[e].value=o,y(e,t,n))})}function A(e,t){return(0,s.isString)(t)?h(t):(0,s.recreateStructure)(S(e))}async function T(e,t){const n={};(0,s.forEach)(t,(t,r)=>{const s=e(t),{storageType:c,computeFn:o,isAction:i}=u[s];o||i||(n[c]||(n[c]={}),n[c][s]=r)});for(let[e,t]of Object.entries(n))await b(e,t);return h(e())}async function b(e,t){if(l.IS_AVAILABE(e)){if(await l.SET_VALUES(e,t))return}g((0,s.map)(t,(e,t)=>[e,{newValue:t}]))}async function m(e,t){const n=p(e);return await T(e,(0,s.map)(t?(0,s.filter)(n,(e,{key:n})=>t.includes(n)):n,(e,{key:t,defaultValue:n})=>[t,n])),h(e())}function j(e){return!arguments[1]||(0,s.isString)(arguments[1])?A.apply(null,arguments):(0,s.isArray)(arguments[1])?a.addStateListener.apply(null,arguments):(0,s.isObject)(arguments[1])?T.apply(null,arguments):void 0}function O(e){Object.assign(l,e)}function h(e){const t=t=>function(e,t){return`${e}${(0,s.isString)(t)&&o.NAMESPACE_DELIMITER||""}${t||""}`}(e,t);return Object.assign(j.bind(null,t),{add:e=>f(t,e,!1),addPersistent:e=>f(t,e,!0),get:e=>A(t,e),set:async e=>await T(t,e),reset:e=>m(t,e),onChange:(e,n)=>(0,a.addStateListener)(t,e,n),removeListener:(e,n)=>(0,a.removeStateListener)(t,e,n),actions:e=>(0,c.addStateActions)(t,e),setStorageUtils:O,onStateChange:g})}O(r.default);const v=h("")},"./src/listeners.ts"(e,t,n){n.r(t),n.d(t,{LISTENERS:()=>o,addStateListener:()=>a,removeStateListener:()=>u,runStateChangeListeners:()=>i});var r=n("./src/index.ts"),s=n("./src/constants.ts"),c=n("./src/helpers.ts");const o={};async function i(e){if(Object.keys(e).length){const{namespace:t}=r.STATE[Object.keys(e)[0]],n=(0,r.getValues)(t);for(let[t,s]of Object.entries(e)){const{listeners:e,key:c}=r.STATE[t];for(const t of e)await t([c],n,s)}const i=(0,c.map)(e,e=>e.slice(s.NAMESPACE_DELIMITER.length));for(const r of o[t()])await r(i,n,(0,c.map)(e,(e,t)=>[e.slice(s.NAMESPACE_DELIMITER.length),t]))}}function a(e,t,n){return(0,c.isFunction)(t)?(o[e()].push(t),(0,r.createStore)(e())):(t.forEach(t=>r.STATE[e(t)].listeners?.push(n)),(0,r.createStore)(e()))}function u(e,t,n){if((0,c.isFunction)(t)){const n=o[e()].findIndex(e=>e===t);return o[e()].splice(n,1),(0,r.createStore)(e())}return t.forEach(t=>{const s=r.STATE[e(t)].listeners,c=s?.findIndex(e=>e===n);s?.splice(c,1)}),(0,r.createStore)(e())}},"./src/storage.ts"(e,t,n){n.r(t),n.d(t,{default:()=>r});const r={GET_TYPE:function(e){return e?"localStorage":""},IS_AVAILABE:function(e){return!!e},UPDATE_STATE:async function(e){const t={};for(const n in e){const e=localStorage.getItem(n);null!==e&&(t[n]=e)}return Object.assign(e,t)},SET_VALUES:async function(e,t){for(let[e,n]of Object.entries(t))localStorage.setItem(e,n);return!1}}},"./src/validation.ts"(e,t,n){n.r(t),n.d(t,{isValid:()=>o});var r=n("./src/index.ts"),s=n("./src/constants.ts");function c(e){const t=e.split(s.NAMESPACE_DELIMITER);return[t.slice(-1)[0],t.join(s.NAMESPACE_DELIMITER)]}const o={Setting:e=>{if(!r.STATE[e]){const[t,n]=c(e);throw new Error(`Setting "${t}" key in "${n}" namespace. DOES NOT EXIST`)}return!0},Defining:e=>{if(r.STATE[e]){const[t,n]=c(e);throw new Error(`Redefining "${t}" key in "${n}" namespace. ALREADY DEFINED`)}return!0}}}};const t={};function n(r){const s=t[r];if(void 0!==s)return s.exports;const c=t[r]={exports:{}};if(!(r in e)){delete t[r];const e=new Error("Cannot find module '"+r+"'");throw e.code="MODULE_NOT_FOUND",e}return e[r](c,c.exports,n),c.exports}n.d=(e,t)=>{if(Array.isArray(t))for(var r=0;r<t.length;){var s=t[r++],c=t[r++];n.o(e,s)?0===c&&r++:0===c?Object.defineProperty(e,s,{enumerable:!0,value:t[r++]}):Object.defineProperty(e,s,{enumerable:!0,get:c})}else for(var s in t)n.o(t,s)&&!n.o(e,s)&&Object.defineProperty(e,s,{enumerable:!0,get:t[s]})},n.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),n.r=e=>{Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};let r=n("./src/index.ts");return r=r.default,r})());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "varstor",
-  "version": "0.6.61",
+  "version": "0.6.63",
   "description": "State manager for web applications and webextensions, employing reactivity, wrapping, and uniting the usage of different storages' values and common variables into a simple universal interface",
   "license": "MIT",
   "author": "Igor Morozov <ismorozs@gmail.com>",
@@ -16,7 +16,11 @@
     "build": "webpack --env production"
   },
   "devDependencies": {
+    "@types/node": "26.6.3",
+    "@types/webpack-env": "1.18.8",
     "minimizer-webpack-plugin": "5.6.1",
+    "ts-loader": "9.6.2",
+    "typescript": "6.0.3",
     "webextension-polyfill": "0.12.0",
     "webpack": "5.108.4",
     "webpack-cli": "7.2.1"

package/src/actions.ts

@@ -0,0 +1,19 @@
+import { STATE, getState, setState, resetState } from ".";
+
+export function addStateActions(namespace: INamespace, actions: IStateActions) {
+  const stateAcessor = {
+    get: getState.bind(null, namespace),
+    set: setState.bind(null, namespace),
+    reset: resetState.bind(null, namespace),
+  };
+
+  for (let [actionName, actionFn] of Object.entries(actions)) {
+    STATE[namespace(actionName)] = {
+      key: actionName,
+      namespace,
+      value: actionFn.bind(null, stateAcessor),
+      isAction: true,
+      listeners: [],
+    };
+  }
+}

package/src/constants.ts

@@ -0,0 +1 @@
+export const NAMESPACE_DELIMITER = "::";

package/src/helpers.ts

@@ -0,0 +1,88 @@
+const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+const ARGUMENT_NAMES = /([^\s,]+)/g;
+
+export function isArray(obj: unknown) {
+  return getObjectType(obj) === "[object Array]";
+}
+
+export function isString(obj: unknown) {
+  return getObjectType(obj) === "[object String]";
+}
+
+export function isFunction(obj: unknown) {
+  return getObjectType(obj) === "[object Function]";
+}
+
+export function isObject(obj: unknown) {
+  return getObjectType(obj) === "[object Object]";
+}
+
+function getObjectType(obj: unknown) {
+  return Object.prototype.toString.call(obj);
+}
+
+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 map<T>(
+  obj: Record<string, T>,
+  cb: (key: string, value: T) => any,
+) {
+  const res = Object.entries(obj).map(([k, v]) => cb(k, v));
+  if (res[0]?.length === 2) {
+    return Object.fromEntries(res);
+  }
+
+  return res;
+}
+
+export function forEach<T>(
+  obj: Record<string, T>,
+  cb: (k: string, v: T) => void,
+) {
+  Object.entries(obj || {}).forEach(([k, v]) => cb(k, v));
+}
+
+export function filter<T>(
+  obj: Record<string, T>,
+  cb: (k: string, v: T) => boolean,
+) {
+  return Object.fromEntries(
+    Object.entries(obj || {}).filter(([k, v]) => cb(k, v) === true),
+  );
+}
+
+export function recreateStructure(value: unknown) {
+  let newValue = value;
+
+  if (isArray(value)) {
+    newValue = [];
+    (value as unknown[]).forEach((v) =>
+      (newValue as unknown[]).push(recreateStructure(v)),
+    );
+    return newValue;
+  }
+
+  if (isObject(value)) {
+    newValue = {};
+    for (let key in value as Record<string, unknown>) {
+      (newValue as Record<string, unknown>)[key] = recreateStructure(
+        (value as Record<string, unknown>)[key],
+      );
+    }
+    return newValue;
+  }
+
+  return newValue;
+}

package/src/index.ts

@@ -0,0 +1,314 @@
+import storageUtils from "./storage";
+
+import {
+  isFunction,
+  isArray,
+  isObject,
+  isString,
+  getParamNames,
+  map,
+  filter,
+  recreateStructure,
+  forEach,
+} from "./helpers";
+
+import { addStateActions } from "./actions";
+
+import { NAMESPACE_DELIMITER } from "./constants";
+
+import { isValid } from "./validation";
+import {
+  runStateChangeListeners,
+  addStateListener,
+  removeStateListener,
+  LISTENERS,
+} from "./listeners";
+
+export const STATE = {} as IState;
+const STORAGE = {} as IStorageFunctions;
+
+setStorageUtils(storageUtils);
+
+async function addState(
+  namespace: INamespace,
+  initialState: IStateDefault,
+  isPersistent: boolean,
+) {
+  const storageType = STORAGE.GET_TYPE(isPersistent);
+  const defaultValues = Object.assign({}, initialState);
+  const values = map(initialState, (k, v) => [namespace(k), v]) as Record<
+    string,
+    unknown
+  >;
+
+  if (STORAGE.IS_AVAILABE(storageType as string)) {
+    await STORAGE.UPDATE_STATE(values, storageType as string);
+  }
+
+  if (!LISTENERS[namespace()]) {
+    LISTENERS[namespace()] = [];
+  }
+
+  for (const key in initialState) {
+    const fullKey = namespace(key);
+    isValid.Defining(fullKey);
+    STATE[fullKey] = setupValue(
+      key,
+      namespace,
+      values[fullKey],
+      defaultValues[key],
+      storageType as string,
+    );
+  }
+
+  return createStore(namespace());
+}
+
+export function setupValue(
+  key: string,
+  namespace: INamespace,
+  value: unknown,
+  defaultValue: unknown,
+  storageType: string,
+): IValue {
+  const fullKey = namespace(key);
+  const isComputedValue = isFunction(value);
+  const dependencies = isComputedValue
+    ? getParamNames(value as IComputeFunction)
+    : [];
+
+  dependencies.forEach((dependency) => {
+    const fullDependencyKey = namespace(dependency);
+    if (!STATE[fullDependencyKey]) {
+      STATE[fullDependencyKey] = {
+        dependants: [],
+        dependencies: [],
+        namespace,
+        storageType,
+      } as IValue;
+    }
+    STATE[fullDependencyKey as keyof typeof STATE].dependants?.push(fullKey);
+  });
+
+  return {
+    key,
+    fullKey,
+    value: isComputedValue
+      ? (value as IComputeFunction).apply(
+          null,
+          getArguments(dependencies, namespace),
+        )
+      : value,
+    computeFn: isComputedValue && (value as IComputeFunction),
+    dependencies,
+    dependants: [],
+    listeners: [],
+    defaultValue,
+    storageType,
+    namespace,
+  };
+}
+
+function getNamespaceState(namespace: INamespace) {
+  return filter(STATE, (k, { key }) => k === namespace(key));
+}
+
+export function getValues(namespace: INamespace) {
+  return map(getNamespaceState(namespace), (k, { key, value }) => [
+    key,
+    value,
+  ]) as Record<string, unknown>;
+}
+
+function getArguments(dependencies: string[], namespace: INamespace) {
+  const values = getValues(namespace);
+  return dependencies.map((name) => values[name as keyof typeof values]);
+}
+
+async function onStateChange(changes: IStateChanges) {
+  const realChanges = {} as IStateChanges;
+
+  for (const key in changes) {
+    const prevValue = STATE[key].value;
+    const newValue = changes[key].newValue;
+
+    if (prevValue !== newValue) {
+      realChanges[key] = { newValue, prevValue };
+      STATE[key].value = newValue;
+    } else {
+      realChanges[key] = { isSame: true };
+    }
+
+    updateDependencies(key, changes, realChanges);
+  }
+
+  await runStateChangeListeners(filter(realChanges, (k, v) => !v.isSame));
+}
+
+function updateDependencies(
+  key: string,
+  changes: IStateChanges,
+  realChanges: IStateChanges,
+) {
+  STATE[key].dependants?.forEach((name) => {
+    const { dependencies, namespace } = STATE[name];
+
+    if (
+      !isEveryDependencyReady(
+        dependencies!,
+        namespace,
+        Object.keys(changes),
+        Object.keys(realChanges),
+      ) ||
+      realChanges[name]
+    ) {
+      return;
+    }
+
+    const prevValue = STATE[name].value;
+    const newValue = (STATE[name].computeFn as IComputeFunction)?.apply(
+      null,
+      getArguments(dependencies!, namespace),
+    );
+
+    if (prevValue !== newValue) {
+      realChanges[name] = { newValue, prevValue };
+      STATE[name].value = newValue;
+      updateDependencies(name, changes, realChanges);
+    }
+  });
+}
+
+function isEveryDependencyReady(
+  dependencies: string[],
+  namespace: INamespace,
+  changesKeys: string[],
+  realChangesKeys: string[],
+) {
+  return dependencies.every((name) => {
+    const fullKey = namespace(name);
+    return (
+      (changesKeys.includes(fullKey) && realChangesKeys.includes(fullKey)) ||
+      !changesKeys.includes(fullKey)
+    );
+  });
+}
+
+export function getState(namespace: INamespace, arg: string) {
+  if (isString(arg)) {
+    return createStore(arg);
+  }
+
+  return recreateStructure(getValues(namespace));
+}
+
+export async function setState(
+  namespace: INamespace,
+  changes: Record<string, unknown>,
+): Promise<unknown> {
+  const storageChanges: Record<string, any> = {};
+
+  forEach(changes, (k, v) => {
+    const fullKey = namespace(k);
+    const { storageType, computeFn, isAction } = STATE[fullKey];
+
+    if (computeFn || isAction) {
+      return;
+    }
+
+    if (!storageChanges[storageType!]) {
+      storageChanges[storageType!] = {};
+    }
+
+    storageChanges[storageType!][fullKey] = v;
+  });
+
+  for (let [storageType, changes] of Object.entries(storageChanges)) {
+    await setValues(storageType, changes);
+  }
+
+  return createStore(namespace());
+}
+
+async function setValues(
+  storageType: string,
+  changes: Record<string, unknown>,
+) {
+  if (STORAGE.IS_AVAILABE(storageType)) {
+    const isAutoUpdate = await STORAGE.SET_VALUES(storageType, changes);
+    if (isAutoUpdate) {
+      return;
+    }
+  }
+
+  onStateChange(
+    map(changes, (k, newValue) => [k, { newValue }]) as Record<string, any>,
+  );
+}
+
+export async function resetState(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 createStore(namespace());
+}
+
+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])) {
+    return addStateListener.apply(
+      null,
+      arguments as unknown as [INamespace, string[], () => {}],
+    );
+  }
+
+  if (isObject(arguments[1])) {
+    return setState.apply(
+      null,
+      arguments as unknown as [INamespace, Record<string, unknown>],
+    );
+  }
+}
+
+function setStorageUtils(storageUtils: IStorageFunctions) {
+  Object.assign(STORAGE, storageUtils);
+}
+
+function addNamespace(namespace: string, str: string) {
+  return `${namespace}${(isString(str) && NAMESPACE_DELIMITER) || ""}${str || ""}`;
+}
+
+export function createStore(_namespace: string) {
+  const namespace = ((key: string) =>
+    addNamespace(_namespace, key)) as INamespace;
+
+  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),
+    reset: (keys: string[]) => resetState(namespace, keys),
+    onChange: (keys: string[], cb: () => {}) =>
+      addStateListener(namespace, keys, cb),
+    removeListener: (keys: string[], cb: () => {}) =>
+      removeStateListener(namespace, keys, cb),
+    actions: (actions: IStateActions) => addStateActions(namespace, actions),
+    setStorageUtils,
+    onStateChange,
+  });
+}
+
+export default createStore("");

package/src/listeners.ts

@@ -0,0 +1,74 @@
+import { STATE, getValues, createStore } from ".";
+import { NAMESPACE_DELIMITER } from "./constants";
+import { map, isFunction } from "./helpers";
+
+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 { listeners, key } = STATE[changeKey];
+      for (const cb of listeners!) {
+        await cb([key], stateValues, change);
+      }
+    }
+
+    const readableKeys = map(realChanges, (k) =>
+      k.slice(NAMESPACE_DELIMITER.length),
+    ) as string[];
+
+    for (const cb of LISTENERS[namespace()]) {
+      await cb(
+        readableKeys,
+        stateValues,
+        map(realChanges, (k, v) => [
+          k.slice(NAMESPACE_DELIMITER.length),
+          v,
+        ]) as IStateChanges,
+      );
+    }
+  }
+}
+
+export function addStateListener(
+  namespace: INamespace,
+  observables: string[] | IStateListener,
+  cb: () => {},
+) {
+  if (isFunction(observables)) {
+    LISTENERS[namespace()].push(observables as IStateListener);
+    return createStore(namespace());
+  }
+
+  (observables as string[]).forEach((key) =>
+    STATE[namespace(key)].listeners?.push(cb),
+  );
+
+  return createStore(namespace());
+}
+
+export function removeStateListener(
+  namespace: INamespace,
+  observables: string[] | IStateListener,
+  removeCb: () => {},
+) {
+  if (isFunction(observables)) {
+    const removeIdx = LISTENERS[namespace()].findIndex(
+      (cb) => cb === observables,
+    );
+    LISTENERS[namespace()].splice(removeIdx, 1);
+    return createStore(namespace());
+  }
+
+  (observables as string[]).forEach((key) => {
+    const listeners = STATE[namespace(key)].listeners;
+    const removeIdx = listeners?.findIndex((cb) => cb === removeCb) as number;
+    listeners?.splice(removeIdx, 1);
+  });
+
+  return createStore(namespace());
+}

package/src/storage.ts

@@ -0,0 +1,37 @@
+async function updateFromLocalStorage(state: IStateDefault) {
+  const stored = {} as IStateDefault;
+  for (const key in state) {
+    const value = localStorage.getItem(key);
+    if (value !== null) {
+      stored[key] = value;
+    }
+  }
+
+  return Object.assign(state, stored);
+}
+
+function getStorageType(isPersistent: boolean) {
+  return isPersistent ? "localStorage" : "";
+}
+
+function isStorageAvailable(storageType: string) {
+  return !!storageType;
+}
+
+async function setStorageValue(
+  storageType: string,
+  changes: Record<string, string>,
+) {
+  for (let [k, v] of Object.entries(changes)) {
+    localStorage.setItem(k, v);
+  }
+
+  return false;
+}
+
+export default {
+  GET_TYPE: getStorageType,
+  IS_AVAILABE: isStorageAvailable,
+  UPDATE_STATE: updateFromLocalStorage,
+  SET_VALUES: setStorageValue,
+};

package/src/types.d.ts

@@ -0,0 +1,44 @@
+type INamespace = (key?: string) => string;
+
+type IComputeFunction = (...args: any[]) => any;
+
+type IValue = {
+  key?: string;
+  fullKey?: string;
+  value?: any;
+  computeFn?: boolean | IComputeFunction;
+  isAction?: boolean;
+  dependencies?: string[];
+  dependants?: string[];
+  storageType?: string;
+  listeners?: any[];
+  defaultValue?: any;
+  namespace: INamespace;
+};
+
+type IState = Record<string, IValue>;
+
+type IStateDefault = Record<string, any>;
+
+type IStateChange = { newValue?: any; prevValue?: any; isSame?: boolean };
+
+type IStateChanges = Record<string, IStateChange>;
+
+type IStorageFunctions = {
+  GET_TYPE: (type: boolean) => boolean | string;
+  IS_AVAILABE: (type: string) => boolean;
+  UPDATE_STATE: (state: IStateDefault, type: string) => IStateDefault;
+  SET_VALUES: (type: string, changes: Record<string, any>) => Promise<boolean>;
+};
+
+type IStateListener = (
+  changes: string[],
+  values: Record<string, any>,
+  data: IStateChanges,
+) => {};
+
+type IStateListeners = Record<string, IStateListener[]>;
+
+type IStateAction = (mutator: IStateMutator, args: any[]) => void;
+
+type IStateActions = Record<string, IStateAction>;

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

@@ -1,10 +1,14 @@
-import { ACCESSORS } from "."
-import { splitFullKey } from "./namespace";
+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) => {
-    if (!ACCESSORS[fullKey]) {
+  Setting: (fullKey: string) => {
+    if (!STATE[fullKey]) {
       const [key, namespace] = splitFullKey(fullKey);
       throw new Error(
         `Setting "${key}" key in "${namespace}" namespace. DOES NOT EXIST`,
@@ -14,8 +18,8 @@ export const isValid = {
     return true;
   },
 
-  Defining: (fullKey) => {
-    if (ACCESSORS[fullKey]) {
+  Defining: (fullKey: string) => {
+    if (STATE[fullKey]) {
       const [key, namespace] = splitFullKey(fullKey);
       throw new Error(
         `Redefining "${key}" key in "${namespace}" namespace. ALREADY DEFINED`,
@@ -23,6 +27,5 @@ export const isValid = {
     }
 
     return true;
-  }
-
+  },
 };