sprae 8.1.3 → 9.0.0

package/src/state.proxy.js

@@ -1,150 +0,0 @@
-// proxy-based store implementation: more flexible, less optimal and with memory leak now
-// FIXME: make simpler prototype chain, likely manual
-// FIXME: detect circular updates
-import { queueMicrotask } from "./util.js"
-
-// currentFx stack of listeners
-let currentFx, batch = [], pendingUpdate
-
-const targetFxs = new WeakMap
-const targetProxy = new WeakMap
-const proxyTarget = new WeakMap
-const _parent = Symbol('parent')
-
-// default root sandbox
-export const sandbox = {
-  Array, Object, Number, String, Boolean, Date,
-  console, window, document, history, location
-}
-
-const callArg = (fn) => fn(), nop = () => { }
-export { callArg as batch };
-
-let lastProp
-
-const handler = {
-  has() {
-    // sandbox everything
-    return true
-  },
-
-  get(target, prop) {
-    if (typeof prop === 'symbol') return lastProp = null, target[prop]
-    if (!(prop in target)) return target[_parent]?.[prop]
-
-    // ignore .length effects called within .push
-    if (lastProp && prop === 'length') return lastProp = null, target[prop];
-
-    // .constructor, .slice etc
-    if (Object.prototype[prop]) return target[prop]
-    if (Array.isArray(target) && Array.prototype[prop] && prop !== 'length') return lastProp = prop, target[prop];
-
-    let value = target[prop]
-
-    if (currentFx) {
-      // get actual target from prototype chain
-      // while (!target.hasOwnProperty(prop)) target = Object.getPrototypeOf(target)
-
-      // register an fx for target-prop path
-      let propFxs = targetFxs.get(target)
-      if (!propFxs) targetFxs.set(target, propFxs = {})
-      if (!propFxs[prop]) propFxs[prop] = [currentFx]
-      else if (!propFxs[prop].includes(currentFx)) propFxs[prop].push(currentFx)
-    }
-
-    // if internal is trackable path - return proxy
-    if ((value && value.constructor === Object) || Array.isArray(value)) {
-      let proxy = targetProxy.get(value)
-      // FIXME: we can avoid saving it here, since it's created by new state
-      if (!proxy) targetProxy.set(value, proxy = new Proxy(value, handler))
-      return proxy
-    }
-
-    return value
-  },
-
-  set(target, prop, value) {
-    // "fake" prototype chain, since regular one doesn't fit
-    if (!(prop in target) && (target[_parent] && prop in target[_parent])) return target[_parent][prop] = value
-
-    // avoid bumping unchanged values
-    if (!Array.isArray(target) && Object.is(target[prop], value)) return true
-
-    target[prop] = value
-
-    // whenever target prop is set, call all dependent fxs
-    let propFxs = targetFxs.get(target)?.[prop]
-
-    if (propFxs) for (let fx of propFxs) {
-      // put fx latest
-      if (fx.planned != null) batch[fx.planned] = null
-      fx.planned = batch.push(fx) - 1
-    }
-    planUpdate()
-
-    // FIXME: unsubscribe / delete effects by setting null/undefined
-    // if (value == null) targetFxs.delete(prev)
-
-    return true
-  },
-
-  deleteProperty(target, prop) {
-    target[prop] = undefined
-    delete target[prop]
-    return true
-  }
-}
-
-export default function state(obj, parent) {
-  if (targetProxy.has(obj)) return targetProxy.get(obj)
-  if (proxyTarget.has(obj)) return obj // is proxy already
-
-  let proxy = new Proxy(obj, handler)
-  targetProxy.set(obj, proxy)
-  proxyTarget.set(proxy, obj)
-
-  // bind all getters & functions here to proxy
-  // FIXME: alternatively we can store getters somewhere
-  let descriptors = Object.getOwnPropertyDescriptors(obj)
-  for (let name in descriptors) {
-    let desc = descriptors[name]
-    if (desc.get) {
-      if (desc.get) desc.get = desc.get.bind(proxy), Object.defineProperty(obj, name, desc)
-    }
-    // else if (typeof desc.value === 'function') {
-    //   desc.value = desc.value.bind(proxy), Object.defineProperty(obj, name, desc)
-    // }
-  }
-
-  // inherit from parent state
-  obj[_parent] = parent ? state(parent) : sandbox
-
-  return proxy
-}
-
-const fx = (fn) => {
-  const call = () => {
-    let prev = currentFx
-    currentFx = call
-    fn()
-    currentFx = prev
-  }
-
-  // collect deps from the first call
-  call()
-
-  return call
-}
-
-const planUpdate = () => {
-  // if (!pendingUpdate) {
-  //   pendingUpdate = true
-  //   queueMicrotask(() => {
-  let fx
-  while (batch.length) fx = batch.shift(), fx && (fx(), fx.planned = null)
-  //     pendingUpdate = false
-  //   })
-  // }
-}
-
-export { fx as effect };

package/src/state.signals-proxy.js

@@ -1,151 +0,0 @@
-// signals-based proxy
-// + we need proxy for sandbox & arrays anyways
-// + it seems faster than defining a bunch of props on sealed state object
-// + we need support signal inputs
-// + signals provide nice tracking mechanism, unlike own arrays
-// + signals detect cycles
-// + it's just robust
-// ? must it modify initial store
-
-import { signal, computed, effect, batch, untracked } from '@preact/signals-core'
-// import { signal, computed } from 'usignal/sync'
-// import { signal, computed } from '@webreflection/signal'
-
-export { effect, computed, batch, untracked }
-
-export const _dispose = (Symbol.dispose ||= Symbol('dispose'));
-export const _signals = Symbol('signals'), _change = Symbol('length');
-
-
-// default root sandbox
-export const sandbox = {
-  Array, Object, Number, String, Boolean, Date,
-  console, window, document, history, navigator, location, screen, localStorage, sessionStorage,
-  alert, prompt, confirm, fetch, performance,
-  setTimeout, setInterval, requestAnimationFrame
-}
-
-const isObject = v => v?.constructor === Object
-const isPrimitive = (value) => value !== Object(value);
-
-// track last accessed property to figure out if .length was directly accessed from expression or via .push/etc method
-let lastProp
-
-export default function createState(values, parent) {
-  if (!isObject(values) && !Array.isArray(values)) return values;
-
-  // ignore existing state as argument
-  if (values[_signals] && !parent) return values;
-  const initSignals = values[_signals]
-
-  // .length signal is stored outside, since it cannot be replaced
-  // _len stores total values length (for objects as well)
-  const isArr = Array.isArray(values), _len = signal(isArr ? values.length : Object.values(values).length),
-    // dict with signals storing values
-    signals = parent ? Object.create((parent = createState(parent))[_signals]) : Array.isArray(values) ? [] : {},
-    proto = signals.constructor.prototype;
-
-  if (parent) for (let key in parent) parent[key] // touch parent keys
-
-  // proxy conducts prop access to signals
-  const state = new Proxy(values, {
-    // sandbox everything
-    has() { return true },
-
-    get(values, key) {
-      // if .length is read within .push/etc - peek signal (don't subscribe)
-      if (isArr)
-        if (key === 'length') return (proto[lastProp]) ? _len.peek() : _len.value;
-        else lastProp = key;
-      if (proto[key]) return proto[key]
-      if (key === _signals) return signals
-      if (key === _change) return _len.value
-      const s = signals[key] || initSignal(key)
-      if (s) return s.value // existing property
-      return sandbox[key] // Array, window etc
-    },
-
-    set(values, key, v) {
-      if (isArr) {
-        // .length
-        if (key === 'length') {
-          batch(() => {
-            // force cleaning up tail
-            for (let i = v, l = signals.length; i < l; i++) delete state[i]
-            _len.value = signals.length = values.length = v;
-          })
-          return true
-        }
-      }
-
-      let newProp = false
-      const s = signals[key] || initSignal(key, v) || (newProp = true, signal())
-      const cur = s.peek()
-
-      // skip unchanged (although can be handled by last condition - we skip a few checks this way)
-      if (v === cur);
-      // stashed _set for values with getter/setter
-      else if (s._set) s._set(v)
-      // patch array
-      else if (Array.isArray(v) && Array.isArray(cur)) {
-        untracked(() => batch(() => {
-          let i = 0, l = v.length, vals = values[key];
-          for (; i < l; i++) cur[i] = vals[i] = v[i]
-          cur.length = l // forces deleting tail signals
-        }))
-      }
-      // .x = y
-      else {
-        // reflect change in values
-        s.value = createState(values[key] = v)
-      }
-
-      // force changing length, if eg. a=[]; a[1]=1 - need to come after setting the item
-      if (isArr) {
-        if (key >= _len.peek()) _len.value = signals.length = values.length = Number(key) + 1
-      }
-      // bump _change for object
-      else if (newProp) {
-        _len.value++
-      }
-
-      return true
-    },
-
-    deleteProperty(values, key) {
-      const s = signals[key]
-      if (s) {
-        const { _del } = s
-        delete s._del
-        delete signals[key]
-        _del?.()
-      }
-      delete values[key]
-      if (!isArr) _len.value--
-      return true
-    }
-  })
-
-  // init signals placeholders (instead of ownKeys & getOwnPropertyDescriptor handlers)
-  // if values are existing proxy (in case of extending parent) - take its signals instead of creating new ones
-  for (let key in values) signals[key] = initSignals?.[key] ?? initSignal(key);
-
-  // initialize signal for provided key
-  function initSignal(key) {
-    // init existing value
-    if (values.hasOwnProperty(key)) {
-      // create signal from descriptor
-      const desc = Object.getOwnPropertyDescriptor(values, key)
-      // getter turns into computed
-      if (desc?.get) {
-        // stash setter
-        (signals[key] = computed(desc.get.bind(state)))._set = desc.set?.bind(state);
-        return signals[key]
-      }
-      // take over existing signal or create new signal
-      return signals[key] = desc.value?.peek ? desc.value : signal(createState(desc.value))
-    }
-  }
-
-  return state
-}

package/src/state.signals.js

@@ -1,82 +0,0 @@
-// signals-based store implementation
-import { signal, computed, effect, batch } from '@preact/signals-core'
-// import { signal, computed } from 'usignal/sync'
-// import { signal, computed } from '@webreflection/signal'
-
-const isSignal = v => v?.peek
-const isState = v => v?.[_st]
-const isObject = v => v?.constructor === Object
-
-const _st = Symbol('state')
-
-export { effect, batch }
-
-export default function createState(values, proto) {
-  if (isState(values) && !proto) return values;
-
-  // define signal accessors - creates signals for all object props
-
-  if (isObject(values)) {
-    const
-      state = Object.create(proto || Object.getPrototypeOf(values)),
-      signals = {},
-      descs = Object.getOwnPropertyDescriptors(values)
-
-    // define signal accessors for exported object
-    for (let key in descs) {
-      let desc = descs[key]
-
-      // getter turns into computed
-      if (desc.get) {
-        let s = signals[key] = computed(desc.get.bind(state))
-        Object.defineProperty(state, key, {
-          get() { return s.value },
-          set: desc.set?.bind(state),
-          configurable: false,
-          enumerable: true
-        })
-      }
-      // regular value creates signal accessor
-      else {
-        let value = desc.value
-        let s = signals[key] = isSignal(value) ? value :
-          signal(
-            // if initial value is an object - we turn it into sealed struct
-            isObject(value) ? Object.seal(createState(value)) :
-              Array.isArray(value) ? createState(value) :
-                value
-          )
-
-        // define property accessor on struct
-        Object.defineProperty(state, key, {
-          get() { return s.value },
-          set(v) {
-            if (isObject(v)) {
-              // new object can have another schema than the new one
-              // so if it throws due to new props access then we fall back to creating new struct
-              if (isObject(s.value)) try { Object.assign(s.value, v); return } catch (e) { }
-              s.value = Object.seal(createState(v));
-            }
-            else if (Array.isArray(v)) s.value = createState(v)
-            else s.value = v;
-
-          },
-          enumerable: true,
-          configurable: false
-        })
-      }
-    }
-
-    Object.defineProperty(state, _st, { configurable: false, enumerable: false, value: true })
-
-    return state
-  }
-
-  // for arrays we turn internals into signal structs
-  // FIXME: make proxy to intercept length and other single values
-  if (Array.isArray(values)) {
-    for (let i = 0; i < values.length; i++) values[i] = createState(values[i])
-  }
-
-  return values
-}

package/src/util.js

@@ -1,13 +0,0 @@
-
-// reset stacktrace or plan for fastest next call
-// https://twitter.com/_developit/status/1634033380940455936
-export const queueMicrotask = Promise.prototype.then.bind(Promise.resolve());
-
-// pick first prop
-export function getFirstProperty(obj) {
-  for (let key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      return obj[key];
-    }
-  }
-}