memorio 1.0.0 → 1.1.0

package/examples/styles.less

@@ -1,169 +0,0 @@
-@import url('https://fonts.googleapis.com/css2?family=Lato');
-
-// Copyright (c) 2024 Dario Passariello
-
-:root {
-  --header-height: 30px;
-  --aside: 300px;
-  --w1: 15px;
-  --w2: 35px;
-  --h1: 20px;
-}
-
-// html{
-// 	display: none;
-// }
-
-* {
-  font-family: 'Lato', sans-serif;
-
-  &::backdrop {
-    background-color: rgba(255, 255, 255, 0);
-  }
-}
-
-html,
-body {
-  cursor: default;
-  margin: 0;
-  padding: 0;
-  font-size: 1em;
-  position: absolute;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-  overflow: hidden;
-
-  &:before {
-    content: '';
-    position: absolute;
-    top: 0;
-    left: 0;
-    right: 0;
-    bottom: 0;
-    background-image: url('bg.jpg');
-    background-size: cover;
-    filter: blur(4px);
-    z-index: 0
-  }
-
-  header {
-    position: absolute;
-    top: 0;
-    height: var(--header-height);
-    left: 0;
-    right: 0;
-    background: black;
-    color: white;
-  }
-
-  aside {
-    padding: 15px 0;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    position: absolute;
-    top: var(--header-height);
-    left: 0;
-    bottom: 0;
-    width: var(--aside);
-    border-right: 1px solid #bbb;
-    overflow: auto;
-    background: #eee;
-
-    section {
-      display: flex
-    }
-
-    hr {
-      width: 150px;
-    }
-
-    .table {
-      .title {
-        display: flex;
-        padding-left: var(--w1);
-        display: flex;
-
-        span {
-          color: cornflowerblue;
-          text-align: center;
-          font-size: .65em;
-          width: var(--w2);
-        }
-      }
-
-      .row {
-        display: flex;
-
-        >span {
-          color: cornflowerblue;
-          font-size: .65em;
-          width: var(--w1);
-          text-align: right;
-          padding-right: 3px;
-        }
-
-        input {
-          width: var(--w2);
-          height: var(--h1);
-          padding: 1px;
-          text-align: center;
-          font-size: .65em;
-          border: 1px solid #ddd;
-        }
-      }
-    }
-  }
-
-  main {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    position: absolute;
-    top: var(--header-height);
-    left: var(--aside);
-    right: 0;
-    bottom: 0;
-    overflow: auto;
-
-    >span {
-      position: absolute;
-      top: 10px;
-      right: 10px;
-      width: unset
-    }
-
-    button {
-      font-size: 1em;
-      margin: 3px;
-      padding: 8px;
-      width: 390px;
-      border-radius: 10px;
-      border: 1px solid #AAA;
-      color: #AAA;
-      text-shadow: black 0 -1px, white 0 1px;
-
-      &:hover {
-        background: #CCC;
-        cursor: pointer;
-      }
-    }
-
-    hr {
-      background: gray;
-      height: 1px;
-      width: 350px;
-      margin: 10px;
-    }
-  }
-
-  footer {
-    position: absolute;
-    bottom: 10px;
-    right: 20px;
-    font-size: .8em;
-  }
-
-}

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