@aaltra-devs/aaltra_universal-storage 1.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Aaltra BVB (https://www.aaltra.eu/)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,64 @@
+# Universal Storage Helper
+
+Universal storage helper for Nuxt projects with tweaks to facilitate use with older browsers.
+
+The project is based on the equivalent [nuxt community module](https://github.com/nuxt-community/universal-storage-module).
+
+## Installation
+
+1. `npm i --save @aaltra-devs/aaltra_universal-storage`
+
+2. Create a nuxt plugin:
+
+```js
+import Storage from "@aaltra-devs/aaltra_universal-storage";
+
+export default function (ctx, inject) {
+  const options = {
+    vuex: {
+      namespace: "storage",
+    },
+    cookie: {
+      prefix: "",
+      options: {
+        path: "/",
+      },
+    },
+    localStorage: {
+      prefix: "",
+    },
+    ignoreExceptions: false,
+  };
+  const storage = new Storage(ctx, options);
+  ctx.$storage = storage;
+  inject("storage", storage);
+}
+```
+
+## Features
+
+- Universal storage support for Nuxt.js applications
+- Works on both client and server side
+- Supports localStorage, cookies, and Vuex state
+- Synchronization between different storage mechanisms
+- Compatible with IE and Safari 10
+- Exception handling options
+
+## API
+
+### Methods
+
+- `setUniversal(key, value)` - Set value in all storage types
+- `getUniversal(key)` - Get value from any storage type
+- `syncUniversal(key, defaultValue)` - Sync value across all storage types
+- `removeUniversal(key)` - Remove value from all storage types
+- `setState(key, value)` - Set value in Vuex state
+- `getState(key)` - Get value from Vuex state
+- `setLocalStorage(key, value)` - Set value in localStorage
+- `getLocalStorage(key)` - Get value from localStorage
+- `setCookie(key, value, options)` - Set cookie value
+- `getCookie(key)` - Get cookie value
+
+## License
+
+BSD-3-Clause

package/dist/lib.esm.js

@@ -0,0 +1,302 @@
+import Vue from 'vue';
+import getProp from 'dotprop';
+import { parse, serialize } from 'cookie';
+
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+var Storage = /*#__PURE__*/function () {
+  function Storage(ctx, options) {
+    _classCallCheck(this, Storage);
+    this.ctx = ctx;
+    this.options = options;
+    this._initState(options.initialState);
+  }
+
+  // ------------------------------------
+  // Universal
+  // ------------------------------------
+  return _createClass(Storage, [{
+    key: "setUniversal",
+    value: function setUniversal(key, value) {
+      // Local state
+      this.setState(key, value);
+      // Cookies
+      this.setCookie(key, value);
+      // Local Storage
+      this.setLocalStorage(key, value);
+      return value;
+    }
+  }, {
+    key: "getUniversal",
+    value: function getUniversal(key) {
+      // Local state
+      var value = this.getState(key);
+
+      // Cookies
+      if (isUnset(value)) {
+        value = this.getCookie(key);
+      }
+
+      // Local Storage
+      if (isUnset(value)) {
+        value = this.getLocalStorage(key);
+      }
+      return value;
+    }
+  }, {
+    key: "syncUniversal",
+    value: function syncUniversal(key, defaultValue) {
+      var value = this.getUniversal(key);
+      if (isUnset(value) && isSet(defaultValue)) {
+        value = defaultValue;
+      }
+      if (isSet(value)) {
+        this.setUniversal(key, value);
+      }
+      return value;
+    }
+  }, {
+    key: "removeUniversal",
+    value: function removeUniversal(key) {
+      this.removeState(key);
+      this.removeLocalStorage(key);
+      this.removeCookie(key);
+    }
+
+    // ------------------------------------
+    // Local state (reactive)
+    // ------------------------------------
+  }, {
+    key: "_initState",
+    value: function _initState(initData) {
+      // Private state is suitable to keep information not being exposed to Vuex store
+      // This helps prevent stealing token from SSR response HTML
+      Vue.set(this, "_state", {});
+
+      // Use vuex for local state's if possible
+      this._useVuex = this.options.vuex && this.ctx.store;
+      if (this._useVuex) {
+        var storeModule = {
+          namespaced: true,
+          state: function state() {
+            return {};
+          },
+          mutations: {
+            SET: function SET(state, payload) {
+              Vue.set(state, payload.key, payload.value);
+            }
+          }
+        };
+        this.ctx.store.registerModule(this.options.vuex.namespace, storeModule, {
+          preserveState: Boolean(this.ctx.store.state[this.options.vuex.namespace])
+        });
+        this.state = this.ctx.store.state[this.options.vuex.namespace];
+      } else {
+        Vue.set(this, "state", {});
+      }
+
+      // Synchronise initial values
+      for (var key in initData) {
+        this.syncUniversal(key, initData[key]);
+      }
+    }
+  }, {
+    key: "setState",
+    value: function setState(key, value) {
+      if (key[0] === "_") {
+        Vue.set(this._state, key, value);
+      } else {
+        if (this._useVuex) {
+          this.ctx.store.commit(this.options.vuex.namespace + "/SET", {
+            key: key,
+            value: value
+          });
+        } else {
+          Vue.set(this.state, key, value);
+        }
+      }
+      return value;
+    }
+  }, {
+    key: "getState",
+    value: function getState(key) {
+      if (key[0] !== "_") {
+        return this.state[key];
+      } else {
+        return this._state[key];
+      }
+    }
+  }, {
+    key: "watchState",
+    value: function watchState(key, fn) {
+      var _this = this;
+      if (this._useVuex) {
+        return this.ctx.store.watch(function (state) {
+          return getProp(state[_this.options.vuex.namespace], key);
+        }, fn);
+      }
+    }
+  }, {
+    key: "removeState",
+    value: function removeState(key) {
+      this.setState(key, undefined);
+    }
+
+    // ------------------------------------
+    // Local storage
+    // ------------------------------------
+  }, {
+    key: "setLocalStorage",
+    value: function setLocalStorage(key, value) {
+      if (typeof localStorage === "undefined" || !this.options.localStorage) {
+        return;
+      }
+      var _key = this.options.localStorage.prefix + key;
+      try {
+        if (isObjectOrArray(value)) {
+          localStorage.setItem(_key, JSON.stringify(value));
+        } else {
+          localStorage.setItem(_key, value);
+        }
+      } catch (e) {
+        if (!this.options.ignoreExceptions) {
+          throw e;
+        }
+      }
+      return value;
+    }
+  }, {
+    key: "getLocalStorage",
+    value: function getLocalStorage(key) {
+      if (typeof localStorage === "undefined" || !this.options.localStorage) {
+        return;
+      }
+      var _key = this.options.localStorage.prefix + key;
+      var value = localStorage.getItem(_key);
+      return decodeValue(value);
+    }
+  }, {
+    key: "removeLocalStorage",
+    value: function removeLocalStorage(key) {
+      if (typeof localStorage === "undefined" || !this.options.localStorage) {
+        return;
+      }
+      var _key = this.options.localStorage.prefix + key;
+      localStorage.removeItem(_key);
+    }
+
+    // ------------------------------------
+    // Cookies
+    // ------------------------------------
+  }, {
+    key: "getCookies",
+    value: function getCookies() {
+      var cookieStr = process.client ? document.cookie : this.ctx.req.headers.cookie;
+      return parse(cookieStr || "") || {};
+    }
+  }, {
+    key: "setCookie",
+    value: function setCookie(key, value) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      if (!this.options.cookie) {
+        return;
+      }
+      var _key = this.options.cookie.prefix + key;
+      var _options = Object.assign({}, this.options.cookie.options, options);
+      var _value = encodeValue(value);
+      var serializedCookie = serialize(_key, _value, _options);
+      if (process.client) {
+        // Set in browser
+        document.cookie = serializedCookie;
+      } else if (process.server && this.ctx.res) {
+        // Send Set-Cookie header from server side
+        this.ctx.res.setHeader("Set-Cookie", serializedCookie);
+      }
+      return value;
+    }
+  }, {
+    key: "getCookie",
+    value: function getCookie(key) {
+      if (!this.options.cookie || process.server && !this.ctx.req) {
+        return;
+      }
+      var _key = this.options.cookie.prefix + key;
+      var cookies = this.getCookies();
+      var value = cookies[_key] ? decodeURIComponent(cookies[_key]) : undefined;
+      return decodeValue(value);
+    }
+  }, {
+    key: "removeCookie",
+    value: function removeCookie(key, options) {
+      this.setCookie(key, undefined, Object.assign({
+        maxAge: -1
+      }, options));
+    }
+  }]);
+}(); // ------------------------------------
+function isUnset(o) {
+  return typeof o === "undefined" || o === null;
+}
+function isSet(o) {
+  return !isUnset(o);
+}
+function isObjectOrArray(obj) {
+  var type = Object.prototype.toString.call(obj);
+  return type === "[object Object]" || type === "[object Array]";
+}
+function encodeValue(val) {
+  if (typeof val === "string") {
+    return val;
+  }
+  return JSON.stringify(val);
+}
+function decodeValue(val) {
+  // Find current value's type
+  var type = Object.prototype.toString.call(val);
+
+  // If value is an object, return object
+  if (type === "[object Object]") {
+    return val;
+  }
+
+  // If value is somehow undefined, return as is (erroneous code)
+  if (type === "undefined") {
+    return val;
+  }
+
+  // Finally try to parse it as json, or fallback to original value
+  try {
+    return JSON.parse(val);
+  } catch (error) {
+    return val;
+  }
+}
+
+export default Storage;

package/dist/lib.js

@@ -0,0 +1,306 @@
+'use strict';
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var Vue = _interopDefault(require('vue'));
+var getProp = _interopDefault(require('dotprop'));
+var cookie = require('cookie');
+
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+var Storage = /*#__PURE__*/function () {
+  function Storage(ctx, options) {
+    _classCallCheck(this, Storage);
+    this.ctx = ctx;
+    this.options = options;
+    this._initState(options.initialState);
+  }
+
+  // ------------------------------------
+  // Universal
+  // ------------------------------------
+  return _createClass(Storage, [{
+    key: "setUniversal",
+    value: function setUniversal(key, value) {
+      // Local state
+      this.setState(key, value);
+      // Cookies
+      this.setCookie(key, value);
+      // Local Storage
+      this.setLocalStorage(key, value);
+      return value;
+    }
+  }, {
+    key: "getUniversal",
+    value: function getUniversal(key) {
+      // Local state
+      var value = this.getState(key);
+
+      // Cookies
+      if (isUnset(value)) {
+        value = this.getCookie(key);
+      }
+
+      // Local Storage
+      if (isUnset(value)) {
+        value = this.getLocalStorage(key);
+      }
+      return value;
+    }
+  }, {
+    key: "syncUniversal",
+    value: function syncUniversal(key, defaultValue) {
+      var value = this.getUniversal(key);
+      if (isUnset(value) && isSet(defaultValue)) {
+        value = defaultValue;
+      }
+      if (isSet(value)) {
+        this.setUniversal(key, value);
+      }
+      return value;
+    }
+  }, {
+    key: "removeUniversal",
+    value: function removeUniversal(key) {
+      this.removeState(key);
+      this.removeLocalStorage(key);
+      this.removeCookie(key);
+    }
+
+    // ------------------------------------
+    // Local state (reactive)
+    // ------------------------------------
+  }, {
+    key: "_initState",
+    value: function _initState(initData) {
+      // Private state is suitable to keep information not being exposed to Vuex store
+      // This helps prevent stealing token from SSR response HTML
+      Vue.set(this, "_state", {});
+
+      // Use vuex for local state's if possible
+      this._useVuex = this.options.vuex && this.ctx.store;
+      if (this._useVuex) {
+        var storeModule = {
+          namespaced: true,
+          state: function state() {
+            return {};
+          },
+          mutations: {
+            SET: function SET(state, payload) {
+              Vue.set(state, payload.key, payload.value);
+            }
+          }
+        };
+        this.ctx.store.registerModule(this.options.vuex.namespace, storeModule, {
+          preserveState: Boolean(this.ctx.store.state[this.options.vuex.namespace])
+        });
+        this.state = this.ctx.store.state[this.options.vuex.namespace];
+      } else {
+        Vue.set(this, "state", {});
+      }
+
+      // Synchronise initial values
+      for (var key in initData) {
+        this.syncUniversal(key, initData[key]);
+      }
+    }
+  }, {
+    key: "setState",
+    value: function setState(key, value) {
+      if (key[0] === "_") {
+        Vue.set(this._state, key, value);
+      } else {
+        if (this._useVuex) {
+          this.ctx.store.commit(this.options.vuex.namespace + "/SET", {
+            key: key,
+            value: value
+          });
+        } else {
+          Vue.set(this.state, key, value);
+        }
+      }
+      return value;
+    }
+  }, {
+    key: "getState",
+    value: function getState(key) {
+      if (key[0] !== "_") {
+        return this.state[key];
+      } else {
+        return this._state[key];
+      }
+    }
+  }, {
+    key: "watchState",
+    value: function watchState(key, fn) {
+      var _this = this;
+      if (this._useVuex) {
+        return this.ctx.store.watch(function (state) {
+          return getProp(state[_this.options.vuex.namespace], key);
+        }, fn);
+      }
+    }
+  }, {
+    key: "removeState",
+    value: function removeState(key) {
+      this.setState(key, undefined);
+    }
+
+    // ------------------------------------
+    // Local storage
+    // ------------------------------------
+  }, {
+    key: "setLocalStorage",
+    value: function setLocalStorage(key, value) {
+      if (typeof localStorage === "undefined" || !this.options.localStorage) {
+        return;
+      }
+      var _key = this.options.localStorage.prefix + key;
+      try {
+        if (isObjectOrArray(value)) {
+          localStorage.setItem(_key, JSON.stringify(value));
+        } else {
+          localStorage.setItem(_key, value);
+        }
+      } catch (e) {
+        if (!this.options.ignoreExceptions) {
+          throw e;
+        }
+      }
+      return value;
+    }
+  }, {
+    key: "getLocalStorage",
+    value: function getLocalStorage(key) {
+      if (typeof localStorage === "undefined" || !this.options.localStorage) {
+        return;
+      }
+      var _key = this.options.localStorage.prefix + key;
+      var value = localStorage.getItem(_key);
+      return decodeValue(value);
+    }
+  }, {
+    key: "removeLocalStorage",
+    value: function removeLocalStorage(key) {
+      if (typeof localStorage === "undefined" || !this.options.localStorage) {
+        return;
+      }
+      var _key = this.options.localStorage.prefix + key;
+      localStorage.removeItem(_key);
+    }
+
+    // ------------------------------------
+    // Cookies
+    // ------------------------------------
+  }, {
+    key: "getCookies",
+    value: function getCookies() {
+      var cookieStr = process.client ? document.cookie : this.ctx.req.headers.cookie;
+      return cookie.parse(cookieStr || "") || {};
+    }
+  }, {
+    key: "setCookie",
+    value: function setCookie(key, value) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      if (!this.options.cookie) {
+        return;
+      }
+      var _key = this.options.cookie.prefix + key;
+      var _options = Object.assign({}, this.options.cookie.options, options);
+      var _value = encodeValue(value);
+      var serializedCookie = cookie.serialize(_key, _value, _options);
+      if (process.client) {
+        // Set in browser
+        document.cookie = serializedCookie;
+      } else if (process.server && this.ctx.res) {
+        // Send Set-Cookie header from server side
+        this.ctx.res.setHeader("Set-Cookie", serializedCookie);
+      }
+      return value;
+    }
+  }, {
+    key: "getCookie",
+    value: function getCookie(key) {
+      if (!this.options.cookie || process.server && !this.ctx.req) {
+        return;
+      }
+      var _key = this.options.cookie.prefix + key;
+      var cookies = this.getCookies();
+      var value = cookies[_key] ? decodeURIComponent(cookies[_key]) : undefined;
+      return decodeValue(value);
+    }
+  }, {
+    key: "removeCookie",
+    value: function removeCookie(key, options) {
+      this.setCookie(key, undefined, Object.assign({
+        maxAge: -1
+      }, options));
+    }
+  }]);
+}(); // ------------------------------------
+function isUnset(o) {
+  return typeof o === "undefined" || o === null;
+}
+function isSet(o) {
+  return !isUnset(o);
+}
+function isObjectOrArray(obj) {
+  var type = Object.prototype.toString.call(obj);
+  return type === "[object Object]" || type === "[object Array]";
+}
+function encodeValue(val) {
+  if (typeof val === "string") {
+    return val;
+  }
+  return JSON.stringify(val);
+}
+function decodeValue(val) {
+  // Find current value's type
+  var type = Object.prototype.toString.call(val);
+
+  // If value is an object, return object
+  if (type === "[object Object]") {
+    return val;
+  }
+
+  // If value is somehow undefined, return as is (erroneous code)
+  if (type === "undefined") {
+    return val;
+  }
+
+  // Finally try to parse it as json, or fallback to original value
+  try {
+    return JSON.parse(val);
+  } catch (error) {
+    return val;
+  }
+}
+
+module.exports = Storage;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@aaltra-devs/aaltra_universal-storage",
+  "version": "1.0.0",
+  "description": "A universal storage library for Nuxt projects.",
+  "scripts": {
+    "build": "rollup -c --environment BUILD:production"
+  },
+  "main": "./dist/lib.js",
+  "module": "./dist/lib.esm.js",
+  "author": "Aaltra <info@aaltra.eu> (https://www.aaltra.eu/)",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "https://bitbucket.org/aaltra/aaltra_universal-storage.git"
+  },
+  "keywords": [
+    "nuxt",
+    "storage",
+    "universal",
+    "cookie",
+    "localstorage",
+    "vuex"
+  ],
+  "devDependencies": {
+    "@babel/core": "^7.7.7",
+    "@babel/preset-env": "^7.7.7",
+    "@rollup/plugin-commonjs": "^11.0.0",
+    "@rollup/plugin-node-resolve": "^6.0.0",
+    "rollup": "^1.27.14",
+    "rollup-plugin-babel": "^4.3.3",
+    "rollup-plugin-vue": "^5.1.4"
+  },
+  "dependencies": {
+    "cookie": "^0.4.0",
+    "dotprop": "^1.2.0",
+    "vue": "^2.6.11"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}