memorio 1.0.0 → 1.0.2

package/functions/cache/index.ts

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

package/functions/observer/index.ts

@@ -1,121 +0,0 @@
-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

@@ -1,108 +0,0 @@
-
-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

@@ -1,199 +0,0 @@
-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

@@ -1,108 +0,0 @@
-
-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

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

package/init.ts

@@ -1,12 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,33 +0,0 @@
-/** @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

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

package/tests/basic.test.ts

@@ -1,50 +0,0 @@
-import { describe, test, expect } from '@jest/globals'
-import '../init'
-
-// Basic state management tests
-describe('Basic State Tests', () => {
-  test('State should exist globally', () => {
-    expect(globalThis.state).toBeDefined()
-  })
-
-  test('Should set and get a simple value', () => {
-    state.testValue = 'hello'
-    expect(state.testValue).toBe('hello')
-  })
-
-  test('Should handle number values', () => {
-    state.number = 42
-    expect(state.number).toBe(42)
-  })
-})
-
-// Object state tests
-describe('Object State Tests', () => {
-  test('Should handle object values', () => {
-    state.obj = { key: 'value' }
-    expect(state.obj.key).toBe('value')
-  })
-
-  test('Should handle nested objects', () => {
-    state.nested = {
-      level1: {
-        level2: 'deep'
-      }
-    }
-    expect(state.nested.level1.level2).toBe('deep')
-  })
-})
-
-// Array state tests
-describe('Array State Tests', () => {
-  test('Should handle array values', () => {
-    state.array = [1, 2, 3]
-    expect(state.array).toEqual([1, 2, 3])
-  })
-
-  test('Should allow array mutations', () => {
-    state.array = [1, 2]
-    state.array.push(3)
-    expect(state.array).toEqual([1, 2, 3])
-  })
-})