varstor 0.0.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Morozov Igor (ismorozs)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# Varstor
+Library for managing the state of applications, employing reactivity, and seamless usage of storage with a simple unified interface

package/dist/varstor.js

@@ -0,0 +1,554 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["Varstor"] = factory();
+	else
+		root["Varstor"] = factory();
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./src/error.js"
+/*!**********************!*\
+  !*** ./src/error.js ***!
+  \**********************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   isKeyPresent: () => (/* binding */ isKeyPresent)
+/* harmony export */ });
+/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! . */ "./src/index.js");
+/* harmony import */ var _namespace__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./namespace */ "./src/namespace.js");
+
+
+
+const isKeyPresent = (fullKey) => {
+  if (!___WEBPACK_IMPORTED_MODULE_0__.ACCESSORS[fullKey]) {
+    const [key, namespace] = fullKey.split(_namespace__WEBPACK_IMPORTED_MODULE_1__.NAMESPACE_DELIMITER);
+    throw new Error (`Trying to access "${key}" key in "${namespace}" namespace, but it doesn't exist`);
+  }
+
+  return true;
+}
+
+
+/***/ },
+
+/***/ "./src/helpers.js"
+/*!************************!*\
+  !*** ./src/helpers.js ***!
+  \************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getKeys: () => (/* binding */ getKeys),
+/* harmony export */   getParamNames: () => (/* binding */ getParamNames),
+/* harmony export */   isArray: () => (/* binding */ isArray),
+/* harmony export */   isFunction: () => (/* binding */ isFunction),
+/* harmony export */   isObject: () => (/* binding */ isObject),
+/* harmony export */   isString: () => (/* binding */ isString),
+/* harmony export */   toCamelCase: () => (/* binding */ toCamelCase)
+/* harmony export */ });
+const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+const ARGUMENT_NAMES = /([^\s,]+)/g;
+
+function isFunction(x) {
+  return typeof x === "function";
+}
+
+function isObject(x) {
+  return typeof x === "object";
+}
+
+function isString(x) {
+  return typeof x === "string";
+}
+
+function isArray(x) {
+  return Array.isArray(x);
+}
+
+function getParamNames(fn) {
+  const fnStr = fn.toString().replace(STRIP_COMMENTS, "");
+  const names = fnStr
+    .slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")"))
+    .match(ARGUMENT_NAMES);
+
+  if (names === null) {
+    return [];
+  }
+
+  return names;
+}
+
+function getKeys(obj, key) {
+  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, v[key]]));
+}
+
+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)}`, "")}`;
+}
+
+
+/***/ },
+
+/***/ "./src/index.js"
+/*!**********************!*\
+  !*** ./src/index.js ***!
+  \**********************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ACCESSORS: () => (/* binding */ ACCESSORS),
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _storage__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./storage */ "./src/storage.js");
+/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./helpers */ "./src/helpers.js");
+/* harmony import */ var _namespace__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./namespace */ "./src/namespace.js");
+/* harmony import */ var _error__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./error */ "./src/error.js");
+
+
+
+
+
+
+
+
+const STATE = {};
+const ACCESSORS = {};
+const COMPUTED_DEPENDENCIES = {};
+const COMPUTED_ARGUMENTS = {};
+
+const STORAGE = {
+  GET_TYPE: null,
+  IS_AVAILABE: null,
+  UPDATE_STATE: null,
+  SET_VALUE: null
+};
+
+setStorageUtils(_storage__WEBPACK_IMPORTED_MODULE_0__["default"]);
+
+async function addState (namespace, initialState, isPersistent) {
+  const storageType = STORAGE.GET_TYPE(isPersistent);
+  const defaultValues = Object.assign({}, initialState);
+  const namespacedValues = (0,_namespace__WEBPACK_IMPORTED_MODULE_2__.namespacify)(namespace(), initialState);
+
+  if (STORAGE.IS_AVAILABE(storageType)) {
+    await STORAGE.UPDATE_STATE(namespacedValues, storageType);
+  }
+
+  const accessors = {};
+  for (const key in initialState) {
+    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 = (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value);
+
+  if (isComputedValue) {
+    setupDependencies(key, value);
+  }
+
+  STATE[key] = {
+    value: isComputedValue ? value.apply(null, getArguments(key)) : value,
+    computeFn: value,
+    listeners: [],
+    defaultValue,
+  };
+
+  return createAccessor(key, value, storageType);
+}
+
+function setupDependencies(computedValueName, computeFn) {
+  const namespace = (0,_namespace__WEBPACK_IMPORTED_MODULE_2__.getNamespace)(computedValueName);
+  const paramNames = (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.getParamNames)(computeFn).map((name) => (0,_namespace__WEBPACK_IMPORTED_MODULE_2__.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[(0,_namespace__WEBPACK_IMPORTED_MODULE_2__.getKey)(name)])
+    .concat(values);
+}
+
+function createAccessor(key, value, storageType) {
+  const accessor = () => STATE[key].value;
+
+  Object.assign(accessor, {
+    valueOf: () => STATE[key].value,
+    toString: () => STATE[key].value,
+    set: (value) => 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];
+    },
+  });
+}
+
+function setValue (key, value, storageType) {
+  if (STORAGE.IS_AVAILABE(storageType)) {
+    const isAutoUpdate = 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((cb) => 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 ((0,_helpers__WEBPACK_IMPORTED_MODULE_1__.isString)(arg)) {
+    return createStore(arg);
+  }
+
+  if ((0,_helpers__WEBPACK_IMPORTED_MODULE_1__.isFunction)(arg)) {
+    return getNamespaceAccessors(namespace(""), arg);
+  }
+
+  return getNamespaceValues(namespace(""));
+}
+
+function getNamespaceValues(namespace) {
+  return (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.getKeys)((0,_namespace__WEBPACK_IMPORTED_MODULE_2__.getByNamespace)(namespace, STATE), "value");
+}
+
+function getNamespaceAccessors (namespace, cb) {
+  const accessors = (0,_namespace__WEBPACK_IMPORTED_MODULE_2__.getByNamespace)(namespace, ACCESSORS);
+  return cb.call(null, accessors, createStore(namespace()));
+}
+
+function setState (namespace, changes) {
+  const noKeys = !Object.keys(changes).length;
+
+  if (noKeys) {
+    resetAllState();
+  } else {
+    for (const [k,v] of Object.entries(changes)) {
+      (0,_error__WEBPACK_IMPORTED_MODULE_3__.isKeyPresent)(namespace(k)) && 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 main () {
+  const arg1 = arguments[1];
+
+  if (!arg1 || (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.isFunction)(arg1) || (0,_helpers__WEBPACK_IMPORTED_MODULE_1__.isString)(arg1)) {
+    return getState.apply(null, arguments);
+  }
+
+  if (Array.isArray(arg1)) {
+    return addStateLitener.apply(null, arguments);
+  }
+
+  if ((0,_helpers__WEBPACK_IMPORTED_MODULE_1__.isObject)(arg1)) {
+    return setState.apply(null, arguments);
+  }
+}
+
+function setStorageUtils(storageUtils) {
+  Object.assign(STORAGE, storageUtils);
+}
+
+function createStore (_namespace) {
+  const namespace = (key) => (0,_namespace__WEBPACK_IMPORTED_MODULE_2__.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: (changes) => setState(namespace, changes),
+    resetAll: () => resetAllState(namespace),
+    onChange: (keys, cb) => addStateLitener(namespace, keys, cb),
+    removeListener: (keys, cb) => removeStateListener(namespace, keys, cb),
+    setStorageUtils,
+    onStateChange,
+  });
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (createStore(""));
+
+
+/***/ },
+
+/***/ "./src/namespace.js"
+/*!**************************!*\
+  !*** ./src/namespace.js ***!
+  \**************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   NAMESPACE_DELIMITER: () => (/* binding */ NAMESPACE_DELIMITER),
+/* harmony export */   addNamespace: () => (/* binding */ addNamespace),
+/* harmony export */   getByNamespace: () => (/* binding */ getByNamespace),
+/* harmony export */   getKey: () => (/* binding */ getKey),
+/* harmony export */   getNamespace: () => (/* binding */ getNamespace),
+/* harmony export */   namespacify: () => (/* binding */ namespacify)
+/* harmony export */ });
+/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./helpers */ "./src/helpers.js");
+
+
+const NAMESPACE_DELIMITER = ":";
+
+function addNamespace(namespace, str) {
+  return `${namespace}${(0,_helpers__WEBPACK_IMPORTED_MODULE_0__.isString)(str) && NAMESPACE_DELIMITER || ""}${str || ""}`;
+}
+
+function getNamespace(str) {
+  return (
+    str.split(NAMESPACE_DELIMITER).slice(0, -1).join(NAMESPACE_DELIMITER)
+  );
+}
+
+function  getKey (str) {
+  return str.split(NAMESPACE_DELIMITER).slice(-1)[0];
+}
+
+function getByNamespace(str, obj) {
+  const namespace = getNamespace(str) + NAMESPACE_DELIMITER;
+
+  return Object.fromEntries(
+    Object.entries(obj)
+      .filter(([k, v]) => k.startsWith(namespace))
+      .map(([k, v]) => [k.slice(namespace.length), v]),
+  );
+}
+
+function namespacify (namespace, obj) {
+  return Object.fromEntries(
+    Object.entries(obj)
+      .map(([k,v]) => [addNamespace(namespace, k), v]
+  ));
+}
+
+
+/***/ },
+
+/***/ "./src/storage.js"
+/*!************************!*\
+  !*** ./src/storage.js ***!
+  \************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+function updateFromLocalStorage(state) {
+  const stored = {};
+  for (const key in state) {
+    stored[key] = localStorage.getItem(key);
+  }
+
+  return Object.assign(state, stored);
+}
+
+function getStorageType(isPersistent) {
+  return isPersistent && "localStorage";
+}
+
+function isStorageAvailable(storageType) {
+  return storageType;
+}
+
+function setStorageValue(storageType, key, value) {
+  window.localStorage.setItem(key, value);
+  return false;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
+  GET_TYPE: getStorageType,
+  IS_AVAILABE: isStorageAvailable,
+  UPDATE_STATE: updateFromLocalStorage,
+  SET_VALUE: setStorageValue,
+});
+
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	const __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		const cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		const module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		if (!(moduleId in __webpack_modules__)) {
+/******/ 			delete __webpack_module_cache__[moduleId];
+/******/ 			const e = new Error("Cannot find module '" + moduleId + "'");
+/******/ 			e.code = 'MODULE_NOT_FOUND';
+/******/ 			throw e;
+/******/ 		}
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter/value functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			if(Array.isArray(definition)) {
+/******/ 				var i = 0;
+/******/ 				while(i < definition.length) {
+/******/ 					var key = definition[i++];
+/******/ 					var binding = definition[i++];
+/******/ 					if(!__webpack_require__.o(exports, key)) {
+/******/ 						if(binding === 0) {
+/******/ 							Object.defineProperty(exports, key, { enumerable: true, value: definition[i++] });
+/******/ 						} else {
+/******/ 							Object.defineProperty(exports, key, { enumerable: true, get: binding });
+/******/ 						}
+/******/ 					} else if(binding === 0) { i++; }
+/******/ 				}
+/******/ 			} else {
+/******/ 				for(var key in definition) {
+/******/ 					if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 						Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 					}
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	let __webpack_exports__ = __webpack_require__("./src/index.js");
+/******/ 	__webpack_exports__ = __webpack_exports__["default"];
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/varstor.min.js

@@ -0,0 +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/error.js"(e,t,n){n.r(t),n.d(t,{isKeyPresent:()=>o});var r=n("./src/index.js"),s=n("./src/namespace.js");const o=e=>{if(!r.ACCESSORS[e]){const[t,n]=e.split(s.NAMESPACE_DELIMITER);throw new Error(`Trying to access "${t}" key in "${n}" namespace, but it doesn't exist`)}return!0}},"./src/helpers.js"(e,t,n){n.r(t),n.d(t,{getKeys:()=>l,getParamNames:()=>u,isArray:()=>a,isFunction:()=>o,isObject:()=>c,isString:()=>i,toCamelCase:()=>f});const r=/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm,s=/([^\s,]+)/g;function o(e){return"function"==typeof e}function c(e){return"object"==typeof e}function i(e){return"string"==typeof e}function a(e){return Array.isArray(e)}function u(e){const t=e.toString().replace(r,""),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:()=>P});var r=n("./src/storage.js"),s=n("./src/helpers.js"),o=n("./src/namespace.js"),c=n("./src/error.js");const i={},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,o.namespacify)(e(),t);f.IS_AVAILABE(r)&&await f.UPDATE_STATE(c,r);const i={};for(const n in t)i[e(n)]=d(e(n),c[e(n)],s[n],r);return Object.assign(a,i),T(e())}function d(e,t,n,r){const c=(0,s.isFunction)(t);return c&&function(e,t){const n=(0,o.getNamespace)(e),r=(0,s.getParamNames)(t).map(e=>(0,o.addNamespace)(n,e));l[e]=r,r.forEach(t=>{u[t]?u[t].push(e):u[t]=[e]})}(e,t),i[e]={value:c?t.apply(null,g(e)):t,computeFn:t,listeners:[],defaultValue:n},function(e,t,n){const r=()=>i[e].value;return Object.assign(r,{valueOf:()=>i[e].value,toString:()=>i[e].value,set:t=>m(e,t,n),onChange:t=>i[e].listeners.push(t),removeListener:t=>i[e].listeners=i[e].listeners.filter(e=>e!==t),reset:()=>m(e,i[e].defaultValue,n)}),new Proxy(r,{get:(t,n)=>Object.keys(r).includes(n)?t[n]:i[e].value[n]})}(e,0,r)}function g(e){const t=A(e);return l[e].map(e=>t[(0,o.getKey)(e)]).concat(t)}function m(e,t,n){if(f.IS_AVAILABE(n)){if(f.SET_VALUE(n,e,t))return}y({[e]:{newValue:t}})}function y(e){const t={};for(const n in e){const r=i[n].value,s=e[n].newValue;r!==s&&(i[n].value=s,t[n]={newValue:s,prevValue:r},E(n,t))}for(const e in t)i[e].listeners.forEach(n=>n(i[e].value,A(e),t[e]))}function E(e,t){const n=u[e];n&&n.forEach(e=>{const n=i[e].value,r=i[e].computeFn.apply(null,g(e));n!==r&&(i[e].value=r,t[e]={newValue:r,prevValue:n},E(e,t))})}function j(e,t){return(0,s.isString)(t)?T(t):(0,s.isFunction)(t)?function(e,t){const n=(0,o.getByNamespace)(e,a);return t.call(null,n,T(e()))}(e(""),t):A(e(""))}function A(e){return(0,s.getKeys)((0,o.getByNamespace)(e,i),"value")}function b(e,t){if(!Object.keys(t).length)S();else for(const[n,r]of Object.entries(t))(0,c.isKeyPresent)(e(n))&&a[e(n)].set(r);return T(e())}function S(e){return Object.entries(a).filter(([t])=>t.startsWith(e())).forEach((e,{reset:t})=>t()),T(e())}function O(e,t,n){return t.forEach(t=>a[e(t)].onChange(n)),T(e())}function v(){const e=arguments[1];return!e||(0,s.isFunction)(e)||(0,s.isString)(e)?j.apply(null,arguments):Array.isArray(e)?O.apply(null,arguments):(0,s.isObject)(e)?b.apply(null,arguments):void 0}function h(e){Object.assign(f,e)}function T(e){const t=t=>(0,o.addNamespace)(e,t);return Object.assign(v.bind(null,t),{add:e=>p(t,e,!1),addPersistent:e=>p(t,e,!0),get:e=>j(t,e),set:e=>b(t,e),resetAll:()=>S(t),onChange:(e,n)=>O(t,e,n),removeListener:(e,n)=>function(e,t,n){return t.forEach(t=>a[e(t)].removeListener(n)),T(e())}(t,e,n),setStorageUtils:h,onStateChange:y})}h(r.default);const P=T("")},"./src/namespace.js"(e,t,n){n.r(t),n.d(t,{NAMESPACE_DELIMITER:()=>s,addNamespace:()=>o,getByNamespace:()=>a,getKey:()=>i,getNamespace:()=>c,namespacify:()=>u});var r=n("./src/helpers.js");const s=":";function o(e,t){return`${e}${(0,r.isString)(t)&&s||""}${t||""}`}function c(e){return e.split(s).slice(0,-1).join(s)}function i(e){return e.split(s).slice(-1)[0]}function a(e,t){const n=c(e)+s;return Object.fromEntries(Object.entries(t).filter(([e,t])=>e.startsWith(n)).map(([e,t])=>[e.slice(n.length),t]))}function u(e,t){return Object.fromEntries(Object.entries(t).map(([t,n])=>[o(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)t[n]=localStorage.getItem(n);return Object.assign(e,t)},SET_VALUE:function(e,t,n){return window.localStorage.setItem(t,n),!1}}}};const t={};function n(r){const s=t[r];if(void 0!==s)return s.exports;const o=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](o,o.exports,n),o.exports}n.d=(e,t)=>{if(Array.isArray(t))for(var r=0;r<t.length;){var s=t[r++],o=t[r++];n.o(e,s)?0===o&&r++:0===o?Object.defineProperty(e,s,{enumerable:!0,value:t[r++]}):Object.defineProperty(e,s,{enumerable:!0,get:o})}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})());

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "varstor",
+  "version": "0.0.1",
+  "description": "Library for managing the state of applications, employing reactivity, and seamless usage of storage with a simple unified interface",
+  "license": "MIT",
+  "author": "Igor Morozov <ismorozs@gmail.com>",
+  "main": "./dist/varstor.js",
+  "scripts": {
+    "start": "webpack",
+    "build": "webpack --env production"
+  },
+  "devDependencies": {
+    "minimizer-webpack-plugin": "5.6.1",
+    "webpack": "5.108.4",
+    "webpack-cli": "7.2.1"
+  },
+  "homepage": "https://github.com/ismorozs/varstor",
+  "repository": "https://github.com/ismorozs/varstor.git",
+  "bugs": "https://github.com/ismorozs/varstor/issues"
+}

package/src/error.js

@@ -0,0 +1,11 @@
+import { ACCESSORS } from "."
+import { NAMESPACE_DELIMITER } from "./namespace";
+
+export const isKeyPresent = (fullKey) => {
+  if (!ACCESSORS[fullKey]) {
+    const [key, namespace] = fullKey.split(NAMESPACE_DELIMITER);
+    throw new Error (`Trying to access "${key}" key in "${namespace}" namespace, but it doesn't exist`);
+  }
+
+  return true;
+}

package/src/helpers.js

@@ -0,0 +1,40 @@
+const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+const ARGUMENT_NAMES = /([^\s,]+)/g;
+
+export function isFunction(x) {
+  return typeof x === "function";
+}
+
+export function isObject(x) {
+  return typeof x === "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, "");
+  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

@@ -0,0 +1,262 @@
+import storageUtils from './storage';
+
+import {
+  isArray, isFunction, isObject, isString,
+  getParamNames,
+  getKeys,
+} from './helpers';
+
+import {
+  addNamespace,
+  getNamespace,
+  getKey,
+  namespacify,
+  getByNamespace,
+} from "./namespace";
+
+import {
+  isKeyPresent
+} from './error';
+
+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) {
+    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, value, storageType);
+}
+
+function setupDependencies(computedValueName, computeFn) {
+  const namespace = getNamespace(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[getKey(name)])
+    .concat(values);
+}
+
+function createAccessor(key, value, storageType) {
+  const accessor = () => STATE[key].value;
+
+  Object.assign(accessor, {
+    valueOf: () => STATE[key].value,
+    toString: () => STATE[key].value,
+    set: (value) => 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];
+    },
+  });
+}
+
+function setValue (key, value, storageType) {
+  if (STORAGE.IS_AVAILABE(storageType)) {
+    const isAutoUpdate = 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((cb) => 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 getKeys(getByNamespace(namespace, STATE), "value");
+}
+
+function getNamespaceAccessors (namespace, cb) {
+  const accessors = getByNamespace(namespace, ACCESSORS);
+  return cb.call(null, accessors, createStore(namespace()));
+}
+
+function setState (namespace, changes) {
+  const noKeys = !Object.keys(changes).length;
+
+  if (noKeys) {
+    resetAllState();
+  } else {
+    for (const [k,v] of Object.entries(changes)) {
+      isKeyPresent(namespace(k)) && 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 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: (changes) => 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

@@ -0,0 +1,36 @@
+import {
+  getKeys, isString, toCamelCase
+} from './helpers';
+
+export const NAMESPACE_DELIMITER = ":";
+
+export function addNamespace(namespace, str) {
+  return `${namespace}${isString(str) && NAMESPACE_DELIMITER || ""}${str || ""}`;
+}
+
+export function getNamespace(str) {
+  return (
+    str.split(NAMESPACE_DELIMITER).slice(0, -1).join(NAMESPACE_DELIMITER)
+  );
+}
+
+export function  getKey (str) {
+  return str.split(NAMESPACE_DELIMITER).slice(-1)[0];
+}
+
+export function getByNamespace(str, obj) {
+  const namespace = getNamespace(str) + 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

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

package/webpack.config.js

@@ -0,0 +1,33 @@
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = (env) => {
+  const options = {
+    entry: "./src/index.js",
+    output: {
+      filename: "varstor.js",
+      library: "Varstor",
+      libraryTarget: "umd",
+      libraryExport: "default",
+      globalObject: "this",
+    },
+    mode: "development",
+    watch: true,
+
+    stats: {
+      colors: true,
+    },
+
+    devtool: false,
+  };
+
+  if(env.production) {
+    options.optimization = {
+      minimize: true,
+      minimizer: [new MinimizerPlugin()],
+    };
+    options.output.filename = "varstor.min.js";
+  }
+
+  return options;
+
+};