memorio 0.2.19 → 1.0.0

package/functions/cache/index.ts

@@ -0,0 +1,19 @@
+Object.defineProperty(
+  window,
+  "cache",
+  {
+    value: new Proxy({}, {}),
+    enumerable: false,
+    configurable: false
+  }
+)
+
+// Object.defineProperties(
+//   cache,
+//   {
+//     get: {},
+//     set: {}
+//   }
+// )
+
+export { }

package/functions/observer/index.ts

@@ -0,0 +1,121 @@
+if (!globalThis.observer) globalThis.observer = null
+
+Object.defineProperty(
+  globalThis,
+  'observer',
+  {
+    enumerable: false
+  }
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// START OBSERVER FUNCTION
+
+observer = (s, cb = null, option = true) => {
+
+  // CHECK IF 'STATE.' OR 'STORE.' EXIST
+  const checkStateOrStore = (s: string) => {
+    const t = s.split('.')
+    if (t[0] !== 'state') {
+      console.error(`Observer Error: You need to declare 'state.' or 'store.'. The '${s}' string is incorrect!`)
+      return false
+    }
+    return true
+  }
+
+  if (!checkStateOrStore(s)) return
+
+  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  // LIST ALL ARRAY FROM STATE
+  if (!s && !cb) {
+    console.error('Observer Error: You need to setup observer correctly, Some parameters are missed!')
+    return
+  }
+
+  ////////////////////////////
+
+  // CHECK
+  if (!s && cb) {
+    console.error(`Observer Error: You need to declare what state need to be monitored as string like 'state.test'.`)
+    return
+  }
+
+  ////////////////////////////
+
+  // RECALL
+  if (s && !cb) {
+    globalThis.memorio.dispatch.listen(
+      String(s),
+      {
+        detail: {
+          name: String(s)
+        }
+      } as any
+    )
+
+    console.debug('called: ', s)
+    return
+  }
+
+  ////////////////////////////
+
+  // SETUP
+  if (s && cb) {
+    if (typeof s !== 'string' || typeof cb !== 'function') {
+      console.error(`Observer Error: name of state need to be a 'string' like 'state.test' and the callback need to be a 'function'`)
+      return
+    }
+
+    globalThis.memorio.dispatch.listen(s, cb, option)
+    return
+  }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+Object.defineProperties(
+  observer,
+  {
+
+    /**
+     * See the list of all your observer (eventListener) actually installed.
+     * @returns The list of all installed observers.
+     */
+    list: {
+      get: () => globalThis.events
+    },
+
+    /////////////////////////////////////////////////////
+
+    /**
+     * Remove an observer.
+     * @param name The name of the observer to remove.
+     */
+    remove: {
+      value: (name: any) => {
+        if (!name) return
+        globalThis.events[name] = ''
+        return
+      }
+    },
+
+    /////////////////////////////////////////////////////
+
+    /**
+     * Remove all observers.
+     * @returns void
+     */
+    removeAll: {
+      get: () => {
+        Object.entries(observer.list).forEach((el: any) => {
+          globalThis.events[el[0]]
+        })
+        return
+      }
+    }
+
+  }
+)
+
+Object.freeze(observer)

package/functions/session/index.ts

@@ -0,0 +1,108 @@
+
+Object.defineProperty(
+  globalThis,
+  'session',
+  {
+    value: new Proxy({}, {}),
+    enumerable: false,
+    configurable: false
+  }
+)
+
+Object.defineProperties(
+  session,
+  {
+    get: {
+      value(name: string) {
+        if (!name) return
+        try {
+          const item = sessionStorage.getItem(name)
+          if (item) return JSON.parse(item)
+          return item
+        } catch (err) {
+          console.error(`Error parsing session item '${name}':`, err)
+        }
+      }
+    },
+
+    set: {
+      value(name: string, value: any) {
+        if (!name) return
+        try {
+
+          if (value === null || value === undefined) sessionStorage.setItem(name, JSON.stringify(null))
+          else if (typeof value === 'object' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string') sessionStorage.setItem(name, JSON.stringify(value))
+          else if (typeof value === 'function') console.error('It\'s not secure to session functions.')
+
+        } catch (err) {
+
+          console.error(`Error setting session item '${name}':`, err)
+
+        }
+      }
+    },
+
+    remove: {
+      value(name: string) {
+        if (!name) return
+        if (sessionStorage.getItem(name)) {
+          sessionStorage.removeItem(name)
+          return true
+        }
+      }
+    },
+
+    delete: {
+      value(name: string) {
+        session.remove(name)
+      }
+
+    },
+
+    removeAll: {
+      value() {
+        sessionStorage.clear()
+        return true
+      }
+    },
+
+    clearAll: {
+      value() {
+        session.removeAll()
+        return true
+      }
+    },
+
+    quota: {
+      value() {
+        if ('storage' in navigator && 'estimate' in navigator.storage) {
+          navigator.storage.estimate()
+            .then(
+              ({ usage, quota }) => {
+                if (usage && quota) console.debug(`Using ${usage / 1024} out of ${quota / 1024} Mb.`)
+              }
+            )
+            .catch(err => { console.error('Error estimating quota:', err) })
+        }
+      }
+    },
+
+    size: {
+      value() {
+        let totalSize = 0
+        for (const key in sessionStorage) {
+          if (sessionStorage.hasOwnProperty(key)) {
+            const item = sessionStorage.getItem(key)
+            if (item) {
+              totalSize += item.length
+            }
+          }
+        }
+        return totalSize
+      }
+    }
+
+  }
+)
+
+Object.freeze(session)

package/functions/state/index.ts

@@ -0,0 +1,199 @@
+Object.defineProperty(
+  memorio,
+  'objPath',
+  {
+    writable: false,
+    configurable: false,
+    enumerable: false,
+    value: (prop: string, object: string[], separator: string = '.'): string => {
+      return object.concat(prop).join(separator)
+    }
+  }
+)
+
+/////////////////////////////////////////////////////
+
+export const buildProxy = (obj: Record<string, any>, callback: (props: any) => void, tree: string[] = []): any => {
+
+  // EVENT FUNCTION FOR OBSERVER
+  const event = (name: string) => {
+    const array = name.split('.')
+    array.forEach(
+      (x, i) => {
+        const command = array.slice(0, i + 1).join('.')
+        globalThis.memorio.dispatch.set(command, { detail: { name: command } })
+      }
+    )
+  }
+
+  ///////////////////////////////////////////////
+
+  // CREATE THE PROXY
+  return new Proxy(
+    obj,
+    {
+      get(target: any, prop: any) {
+        // Handle special methods first
+        if (prop === 'list') {
+          const result = {}
+          for (const key in target) {
+            if (typeof target[key] !== 'function' && !['list', 'remove', 'removeAll'].includes(key)) {
+              result[key] = target[key]
+            }
+          }
+          return result
+        }
+
+        if (prop === 'remove') {
+          return function (key: string) {
+            if (key in target && !['list', 'remove', 'removeAll'].includes(key)) {
+              delete target[key]
+              return true
+            }
+            return false
+          }
+        }
+
+        if (prop === 'removeAll') {
+          return function () {
+            for (const key in target) {
+              if (typeof target[key] !== 'function' && !['list', 'remove', 'removeAll'].includes(key)) {
+                delete target[key]
+              }
+            }
+            return true
+          }
+        }
+
+        if (Object.isFrozen(target[prop])) return target[prop]
+
+        try {
+          const value = Reflect.get(target, prop)
+          if (value && typeof value === 'object' && ['Array', 'Object'].includes(value.constructor.name)) {
+            return buildProxy(value, callback, tree.concat(prop as string))
+          }
+          return value
+        } catch (error) {
+          console.error('Error: ', error)
+          return undefined
+        }
+      },
+
+      set(target: any, prop: string, value: any): boolean {
+
+        if (target[prop] && typeof target[prop] === 'object' && Object.isFrozen(target[prop])) {
+          console.error(`Error: state '${prop}' is locked`)
+          return
+        }
+
+        try {
+
+          const path = globalThis.memorio.objPath(prop as string, tree)
+
+          callback(
+            {
+              action: 'set',
+              path,
+              target,
+              newValue: value,
+              previousValue: Reflect.get(target, prop)
+            }
+          )
+
+          event('state.' + path)
+
+          Reflect.set(target, prop, value)
+
+          // DEFINE LOCK PROPERTY FUNCTION
+          if (target[prop] && typeof target[prop] === 'object') {
+
+            Reflect.defineProperty(
+              target[prop],
+              'lock',
+              {
+                value() {
+                  Object.defineProperty(
+                    target,
+                    prop,
+                    {
+                      writable: false,
+                      enumerable: false
+                      // configurable: false
+                    }
+                  )
+
+                  Object.freeze(target[prop])
+                }
+              }
+            )
+
+          }
+
+          return true
+
+        } catch (error) {
+
+          console.error('Error in set trap:', error)
+          return false
+
+        }
+
+      },
+
+      deleteProperty(target: any, prop: string | symbol): boolean {
+        try {
+          const path = globalThis.memorio.objPath(prop as string, tree)
+          callback({ action: 'delete', path, target })
+          return Reflect.deleteProperty(target, prop)
+        } catch (error) {
+          console.error('Error in deleteProperty trap:', error)
+          return false
+        }
+      }
+
+    }
+
+  )
+
+}
+
+// Initialize base state object
+const baseState = {}
+
+// SET STATE AS PROXY
+!globalThis?.state
+  ? globalThis.state = buildProxy(baseState, () => { })
+  : globalThis.state = state
+
+///////////////////////////////////////////////
+
+// TEST IF STATE IS A PROXY
+const testProxy = new WeakSet()
+
+testProxy.add(state)
+
+setInterval(
+  () => {
+    if (!testProxy.has(state)) {
+      alert('memorio State is compromised, check if you override it and please reload the page')
+      for (let i = 1; i < 99999; i++) clearInterval(i)
+      stop()
+    }
+  }, 1000
+)
+
+///////////////////////////////////////////////
+
+// DEFINE THE STATE IN GLOBAL
+Object.defineProperty(
+  globalThis,
+  'state',
+  {
+    enumerable: false,
+    configurable: false
+  }
+)
+
+///////////////////////////////////////////////
+
+// END

package/functions/store/index.ts

@@ -0,0 +1,108 @@
+
+Object.defineProperty(
+  globalThis,
+  'store',
+  {
+    value: new Proxy({}, {}),
+    enumerable: false,
+    configurable: false
+  }
+)
+
+Object.defineProperties(
+  store,
+  {
+    get: {
+      value(name: string) {
+        if (!name) return
+        try {
+          const item = localStorage.getItem(name)
+          if (item) return JSON.parse(item)
+          return item
+        } catch (err) {
+          console.error(`Error parsing store item '${name}':`, err)
+        }
+      }
+    },
+
+    set: {
+      value(name: string, value: any) {
+        if (!name) return
+        try {
+
+          if (value === null || value === undefined) localStorage.setItem(name, JSON.stringify(null))
+          else if (typeof value === 'object' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string') localStorage.setItem(name, JSON.stringify(value))
+          else if (typeof value === 'function') console.error('It\'s not secure to store functions.')
+
+        } catch (err) {
+
+          console.error(`Error setting store item '${name}':`, err)
+
+        }
+      }
+    },
+
+    remove: {
+      value(name: string) {
+        if (!name) return
+        if (localStorage.getItem(name)) {
+          localStorage.removeItem(name)
+          return true
+        }
+      }
+    },
+
+    delete: {
+      value(name: string) {
+        store.remove(name)
+      }
+
+    },
+
+    removeAll: {
+      value() {
+        localStorage.clear()
+        return true
+      }
+    },
+
+    clearAll: {
+      value() {
+        store.removeAll()
+        return true
+      }
+    },
+
+    quota: {
+      value() {
+        if ('storage' in navigator && 'estimate' in navigator.storage) {
+          navigator.storage.estimate()
+            .then(
+              ({ usage, quota }) => {
+                if (usage && quota) console.debug(`Using ${usage / 1024} out of ${quota / 1024} Mb.`)
+              }
+            )
+            .catch(err => { console.error('Error estimating quota:', err) })
+        }
+      }
+    },
+
+    size: {
+      value() {
+        let totalSize = 0
+        for (const key in localStorage) {
+          if (localStorage.hasOwnProperty(key)) {
+            const item = localStorage.getItem(key)
+            if (item) {
+              totalSize += item.length
+            }
+          }
+        }
+        return totalSize
+      }
+    }
+
+  }
+)
+
+Object.freeze(store)

package/index.ts

@@ -0,0 +1 @@
+import "./init"

package/init.ts

@@ -0,0 +1,12 @@
+///////////////////////////////////////////////////////////////////////////////
+// LOAD SCRIPTS
+
+import "dphelper.types"
+
+import './config/global'
+import './config/dispatch'
+import './functions/state'
+import './functions/observer'
+import './functions/store'
+import './functions/session'
+import './functions/cache'

package/jest.config.mjs

@@ -0,0 +1,33 @@
+/** @type {import('jest').Config} */
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'jsdom',
+  setupFilesAfterEnv: ['./tests/setup.ts'],
+  transform: {
+    '^.+\\.tsx?$': ['ts-jest', {
+      useESM: true
+    }]
+  },
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1'
+  },
+  collectCoverageFrom: [
+    'functions/**/*.ts',
+    'config/**/*.ts',
+    '*.ts',
+    '!**/*.d.ts',
+    '!**/node_modules/**',
+    '!**/dist/**'
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['json', 'lcov', 'text', 'clover'],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80
+    }
+  }
+}

package/jest.setup.js

@@ -0,0 +1,2 @@
+// Mock the window object
+global.window = {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorio",
-  "version": "0.2.19",
+  "version": "1.0.0",
   "type": "module",
   "main": "index.js",
   "scripts": {
@@ -21,9 +21,6 @@
   "typings": "./types/*",
   "description": "Memorio, State + Observer and Store for a easy life ",
   "license": "MIT",
-  "deprecated": false,
-  "preferGlobal": true,
-  "target": "node",
   "copyright": "Dario Passariello, BigLogic ca - a51.dev is a BigLogic project",
   "homepage": "https://a51.gitbook.io/memorio",
   "author": {
@@ -46,9 +43,6 @@
       "email": "valeriacalascaglitta@gmail.com"
     }
   ],
-  "globals": {
-    "memorio": {}
-  },
   "keywords": [
     "biglogic",
     "a51",
@@ -83,8 +77,8 @@
     "@eslint/js": "9.34.0",
     "@types/jest": "30.0.0",
     "@types/node": "^24.3.0",
-    "@typescript-eslint/eslint-plugin": "8.40.0",
-    "@typescript-eslint/parser": "8.40.0",
+    "@typescript-eslint/eslint-plugin": "8.41.0",
+    "@typescript-eslint/parser": "8.41.0",
     "dphelper.types": "0.0.19",
     "esbuild": "^0.25.9",
     "esbuild-plugin-clean": "^1.0.1",
@@ -93,7 +87,7 @@
     "jest": "30.0.5",
     "jest-environment-jsdom": "30.0.5",
     "ts-jest": "29.4.1",
-    "ts-loader": "^9.5.2",
+    "ts-loader": "^9.5.4",
     "ts-node": "10.9.2",
     "tslib": "^2.8.1",
     "typescript": "5.9.2"