sprae 12.0.1 → 12.1.0

package/store.js

@@ -1,18 +1,24 @@
 // signals-based proxy
-import { signal, computed, batch, untracked } from './core.js'
+import { signal, computed, batch, untracked, _add } from './core.js'
 
 
 // _signals allows both storing signals and checking instance, which would be difficult with WeakMap
 export const _signals = Symbol('signals'),
+  // _change is a signal that tracks changes to the object keys or array length
   _change = Symbol('change'),
+  // _set is stashed setter for computed values
   _set = Symbol('set')
 
+// a hack to simulate sandbox for `with` in evaluator
+let sandbox = true
+
 // object store is not lazy
 // parent defines parent scope or sandbox
-export const store = (values, parent = globalThis) => {
+export const store = (values, parent) => {
   if (!values) return values
 
   // ignore globals
+  // FIXME: handle via has trap
   if (values[Symbol.toStringTag]) return values;
 
   // bypass existing store
@@ -22,23 +28,64 @@ export const store = (values, parent = globalThis) => {
   if (values.constructor !== Object) return Array.isArray(values) ? list(values) : values
 
   // _change stores total number of keys to track new props
-  // NOTE: be careful
   let keyCount = Object.keys(values).length,
-      signals = {  }
+    signals = {}
 
   // proxy conducts prop access to signals
-  let state = new Proxy(Object.assign(signals, {[_change]: signal(keyCount), [_signals]: signals}), {
-    get: (_, k) => (k in signals ? (signals[k] ? signals[k].valueOf() : signals[k]) : parent[k]),
-    set: (_, k, v, _s) => (k in signals ? set(signals, k, v) : (create(signals, k, v), signals[_change].value = ++keyCount), 1), // bump length for new signal
-    // FIXME: try to avild calling Symbol.dispose here
-    deleteProperty: (_, k) => (k in signals && (k[0] != '_' && signals[k]?.[Symbol.dispose]?.(), delete signals[k], signals[_change].value = --keyCount), 1),
-    // subscribe to length when object is spread
+  let state = new Proxy(Object.assign(signals, {
+    [_change]: signal(keyCount),
+    [_signals]: signals
+  }), {
+    get: (_, k) => {
+      // console.log('GET', k, signals)
+      if (k in signals) return (signals[k] ? signals[k].valueOf() : signals[k])
+      return parent ? parent[k] : globalThis[k]
+    },
+
+    set: (_, k, v, _s) => {
+      // console.group('SET', k, v, signals, k in signals)
+      if (k in signals) return set(signals, k, v), 1
+
+      // turn off sandbox to check if parents have the prop - we don't want to create new prop in global scope
+      sandbox = false
+
+      // write transparency for parent scope, unlike prototype chain
+      // if prop is defined in parent scope (except global) - write there
+      if (parent && k in parent) {
+        parent[k] = v
+      }
+      // else create in current scope
+      else {
+        create(signals, k, v)
+        signals[_change].value = ++keyCount
+      }
+
+      sandbox = true
+
+      // console.groupEnd()
+      // bump length for new signal
+      return 1
+    },
+
+    // FIXME: try to avild calling Symbol.dispose here. Maybe _delete method?
+    deleteProperty: (_, k) => {
+      k in signals && (k[0] != '_' && signals[k]?.[Symbol.dispose]?.(), delete signals[k], signals[_change].value = --keyCount)
+      return 1
+    },
+
+    // subscribe to length when spreading
     ownKeys: () => (signals[_change].value, Reflect.ownKeys(signals)),
-    has: _ => 1 // sandbox prevents writing to global
-  }),
 
-    // init signals for values
-    descs = Object.getOwnPropertyDescriptors(values)
+    // sandbox prevents writing to global
+    has: (_, k) => {
+      if (k in signals) return true
+      if (parent) return k in parent
+      return sandbox
+    }
+  })
+
+  // init signals for values
+  const descs = Object.getOwnPropertyDescriptors(values)
 
   for (let k in values) {
     // getter turns into computed
@@ -53,8 +100,6 @@ export const store = (values, parent = globalThis) => {
   return state
 }
 
-const mut = ['push', 'pop', 'shift', 'unshift', 'splice']
-
 // array store - signals are lazy since arrays can be very large & expensive
 const list = (values, parent = globalThis) => {
 
@@ -65,15 +110,16 @@ const list = (values, parent = globalThis) => {
     isMut = false,
 
     // since array mutator methods read .length internally only once, we disable it on the moment of call, allowing rest of operations to be reactive
-    mut = fn => function () {isMut = true; return fn.apply(this, arguments); },
+    mut = fn => function () { isMut = true; return fn.apply(this, arguments); },
 
     length = signal(values.length),
 
-    // proxy conducts prop access to signals
+    // proxy passes prop access to signals
     state = new Proxy(
       Object.assign(signals, {
         [_change]: length,
         [_signals]: signals,
+        // patch mutators
         push: mut(signals.push),
         pop: mut(signals.pop),
         shift: mut(signals.shift),
@@ -124,7 +170,7 @@ const list = (values, parent = globalThis) => {
 }
 
 // create signal value, skip untracked
-const create = (signals, k, v) => (signals[k] = k[0] == '_' || v?.peek ? v : signal(store(v)))
+const create = (signals, k, v) => (signals[k] = (k[0] == '_' || v?.peek) ? v : signal(store(v)))
 
 // set/update signal value
 const set = (signals, k, v, _s, _v) => {
@@ -138,10 +184,12 @@ const set = (signals, k, v, _s, _v) => {
           // if we update plain array (stored in signal) - take over value instead
           // since input value can be store, we have to make sure we don't subscribe to its length or values
           // FIXME: generalize to objects
-          _change in _v ? untracked(() => batch(() => {
-            for (let i = 0; i < v.length; i++) _v[i] = v[i]
-            _v.length = v.length // forces deleting tail signals
-          })) : _s.value = v :
+          _change in _v ?
+            untracked(() => batch(() => {
+              for (let i = 0; i < v.length; i++) _v[i] = v[i]
+              _v.length = v.length // forces deleting tail signals
+            })) :
+            (_s.value = v) :
           // .x = y
           (_s.value = store(v))
     )
@@ -150,6 +198,6 @@ const set = (signals, k, v, _s, _v) => {
 
 // make sure state contains first element of path, eg. `a` from `a.b[c]`
 // NOTE: we don't need since we force proxy sandbox
-// export const ensure = (state, expr, name = expr.match(/^\w+(?=\s*(?:\.|\[|$))/)) => name && (state[_signals][name[0]] ??= null)
+// export const ensure = (state, expr, _name = expr.match(/^\w+(?=\s*(?:\.|\[|$))/)) => _name && (state[_signals][_name[0]] ??= null)
 
 export default store