memorio 1.0.0 → 1.1.0

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])
-  })
-})

package/tests/cache.test.ts

@@ -1,52 +0,0 @@
-import { describe, test, expect, beforeEach } from '@jest/globals'
-import '../config/global.js'
-import '../init'
-
-describe('Cache Tests', () => {
-  beforeEach(() => {
-    // Clear cache if possible
-    try {
-      cache.clear()
-    } catch (e) {
-      // Ignore if clear is not available
-    }
-  })
-
-  test('should set and get cache values', () => {
-    cache.test = 'value'
-    expect(cache.test).toBe('value')
-  })
-
-  test('should handle object values', () => {
-    const testObj = { key: 'value' }
-    cache.testObj = testObj
-    expect(cache.testObj).toEqual(testObj)
-  })
-
-  test('should handle array values', () => {
-    const testArray = [1, 2, 3]
-    cache.testArray = testArray
-    expect(cache.testArray).toEqual(testArray)
-  })
-
-  test('should handle nested objects', () => {
-    const nested = {
-      level1: {
-        level2: {
-          data: 'test'
-        }
-      }
-    }
-    cache.nested = nested
-    expect(cache.nested.level1.level2.data).toBe('test')
-  })
-
-  test('should handle persistence', () => {
-    cache.persistent = 'persist'
-    expect(cache.persistent).toBe('persist')
-
-    // Test removal
-    delete cache.persistent
-    expect(cache.persistent).toBeUndefined()
-  })
-})

package/tests/observer.test.ts

@@ -1,62 +0,0 @@
-import { describe, test, expect, jest, beforeEach } from '@jest/globals'
-import '../config/global.js'
-
-// Initialize memorio object first
-if (!globalThis.memorio) {
-  Object.defineProperty(globalThis, 'memorio', {
-    value: {},
-    writable: false,
-    configurable: false,
-    enumerable: false
-  })
-}
-
-// Then import other modules
-import { buildProxy } from '../functions/state/index.js'
-import '../init'
-
-describe('Observer Tests', () => {
-  beforeEach(() => {
-    // Reset state for each test
-    globalThis.state = buildProxy({}, () => { })
-  })
-
-  test('should observe state changes', async () => {
-    const mockCallback = jest.fn()
-    observer('state.test', mockCallback)
-
-    state.test = 'value'
-
-    // Observer events are async, so we need to wait
-    await new Promise(resolve => setTimeout(resolve, 100))
-    expect(mockCallback).toHaveBeenCalled()
-  })
-
-  test('should handle multiple observers', async () => {
-    const mockCallback1 = jest.fn()
-    const mockCallback2 = jest.fn()
-
-    observer('state.test', mockCallback1)
-    observer('state.test', mockCallback2)
-
-    state.test = 'value'
-
-    await new Promise(resolve => setTimeout(resolve, 100))
-    expect(mockCallback1).toHaveBeenCalled()
-    expect(mockCallback2).toHaveBeenCalled()
-  })
-
-  test('should observe nested state changes', async () => {
-    const mockCallback = jest.fn()
-
-    // Initialize nested state structure first
-    state.nested = {}
-    observer('state.nested.deep', mockCallback)
-
-    // Then set the deep value
-    state.nested.deep = 'value'
-
-    await new Promise(resolve => setTimeout(resolve, 100))
-    expect(mockCallback).toHaveBeenCalled()
-  })
-})

package/tests/setup.ts

@@ -1,48 +0,0 @@
-
-import { jest } from '@jest/globals'
-
-// Mock localStorage and sessionStorage
-const localStorageMock = {
-  getItem: jest.fn(),
-  setItem: jest.fn(),
-  removeItem: jest.fn(),
-  clear: jest.fn(),
-  length: 0,
-  key: jest.fn()
-}
-
-const sessionStorageMock = {
-  getItem: jest.fn(),
-  setItem: jest.fn(),
-  removeItem: jest.fn(),
-  clear: jest.fn(),
-  length: 0,
-  key: jest.fn()
-}
-
-Object.defineProperty(globalThis, 'localStorage', { value: localStorageMock })
-Object.defineProperty(globalThis, 'sessionStorage', { value: sessionStorageMock })
-
-// Mock navigator.storage
-Object.defineProperty(globalThis, 'navigator', {
-  value: {
-    storage: {
-      estimate: () => Promise.resolve({ usage: 0, quota: 1000000 })
-    }
-  }
-})
-
-// Initialize global objects
-globalThis.state = {}
-globalThis.store = {
-  get: jest.fn(key => null),
-  set: jest.fn((key, value) => true),
-  remove: jest.fn(() => true),
-  removeAll: jest.fn(() => true),
-  delete: jest.fn(() => true),
-  clearAll: jest.fn(() => true),
-  quota: jest.fn(() => ({ usage: 0, quota: 1000000 })),
-  size: jest.fn(() => 0)
-}
-globalThis.cache = {}
-globalThis.observer = jest.fn()

package/tests/state.test.ts

@@ -1,45 +0,0 @@
-import { describe, test, expect, beforeEach } from '@jest/globals'
-import '../config/global.js'
-import { buildProxy } from '../functions/state/index.js'
-import '../init'
-
-describe('State Management', () => {
-  beforeEach(() => {
-    // Reset state by creating a new proxy
-    globalThis.state = buildProxy({}, () => { })
-  })
-
-  test('should set and get state value', () => {
-    state.test = 'value'
-    expect(state.test).toBe('value')
-  })
-
-  test('should list all states', () => {
-    state.test1 = 'value1'
-    state.test2 = 'value2'
-    const list = state.list
-    expect(list).toHaveProperty('test1')
-    expect(list).toHaveProperty('test2')
-  })
-
-  test('should remove state', () => {
-    state.test = 'value'
-    state.remove('test')
-    expect(state.test).toBeUndefined()
-  })
-
-  test('should remove all states', () => {
-    state.test1 = 'value1'
-    state.test2 = 'value2'
-    state.removeAll()
-    expect(state.list).toEqual({})
-  })
-
-  test('should lock object state', () => {
-    state.test = { prop: 'value' }
-    state.test.lock()
-    expect(() => {
-      state.test.newProp = 'value'
-    }).toThrow()
-  })
-})

package/tests/store.test.ts

@@ -1,62 +0,0 @@
-import { describe, test, expect, jest, beforeEach } from '@jest/globals'
-import '../config/global.js'
-import '../init'
-
-describe('Store Tests', () => {
-  let mockStore = {}
-
-  beforeEach(() => {
-    mockStore = {}
-    localStorage.clear()
-    jest.spyOn(localStorage, 'getItem').mockImplementation(key => mockStore[key] || null)
-    jest.spyOn(localStorage, 'setItem').mockImplementation((key, value) => {
-      mockStore[key] = value
-    })
-    jest.spyOn(localStorage, 'removeItem').mockImplementation(key => {
-      delete mockStore[key]
-    })
-    jest.spyOn(localStorage, 'clear').mockImplementation(() => {
-      mockStore = {}
-    })
-  })
-
-  test('should set and get store values', () => {
-    const testValue = 'test value'
-    store.set('test', testValue)
-    expect(localStorage.setItem).toHaveBeenCalledWith('test', JSON.stringify(testValue))
-    expect(store.get('test')).toBe(testValue)
-  })
-
-  test('should handle object values', () => {
-    const testObj = { key: 'value' }
-    store.set('test', testObj)
-    expect(localStorage.setItem).toHaveBeenCalledWith('test', JSON.stringify(testObj))
-    expect(store.get('test')).toEqual(testObj)
-  })
-
-  test('should remove store item', () => {
-    store.set('test', 'value')
-    store.remove('test')
-    expect(localStorage.removeItem).toHaveBeenCalledWith('test')
-    expect(store.get('test')).toBeNull()
-  })
-
-  test('should remove all store items', () => {
-    store.set('test1', 'value1')
-    store.set('test2', 'value2')
-    store.removeAll()
-    expect(localStorage.clear).toHaveBeenCalled()
-    expect(store.get('test1')).toBeNull()
-    expect(store.get('test2')).toBeNull()
-  })
-
-  test('should get store size', () => {
-    mockStore = {}
-    store.removeAll()
-    store.set('test1', 'value1')
-    store.set('test2', 'value2')
-    const size = Object.keys(mockStore).length
-    expect(typeof size).toBe('number')
-    expect(size).toBe(2)
-  })
-})

package/tsconfig.json

@@ -1,67 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": [
-      "es2022",
-      "dom"
-    ],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "types": [
-      "node"
-    ],
-    "strict": true,
-    "noEmit": false,
-    "noImplicitThis": true,
-    "noUnusedLocals": true,
-    "importHelpers": true,
-    "skipLibCheck": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noImplicitAny": false,
-    "preserveConstEnums": true,
-    "removeComments": true,
-    "sourceMap": false,
-    "allowJs": true,
-    "esModuleInterop": true,
-    "strictNullChecks": false,
-    "strictPropertyInitialization": false,
-    "jsx": "react",
-    "moduleDetection": "force",
-    "baseUrl": ".",
-    "outDir": "./dist/",
-    "target": "es2022",
-    "rootDirs": [
-      "./"
-    ],
-    "paths": {
-      "/*": [
-        "./*"
-      ]
-    }
-  },
-  "include": [
-    "index.d.ts",
-    "./types/memorio.d.ts",
-    "./**/*.ts",
-    "./**/*.tsx"
-  ],
-  "types": [
-    "node"
-  ],
-  "typeRoots": [
-    "./types/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "private",
-    "archive",
-    "*backup",
-    "dist",
-    ".old*",
-    ".OLD*",
-    "#OLD*",
-    "@OLD*",
-  ]
-}