aberdeen 1.0.13 → 1.1.0

package/dist/aberdeen.js

@@ -194,7 +194,7 @@ class ContentScope extends Scope {
   getInsertAfterNode() {
     return this.getLastNode() || this.getPrecedingNode();
   }
-  onChange(index, newData, oldData) {
+  onChange() {
     queue(this);
   }
   getChildPrevSibling() {
@@ -336,32 +336,6 @@ class SetArgScope extends ChainedScope {
     currentScope = savedScope;
   }
 }
-var immediateQueue = new ReverseSortedSet("prio");
-
-class ImmediateScope extends RegularScope {
-  onChange(index, newData, oldData) {
-    immediateQueue.add(this);
-  }
-}
-var immediateQueueRunning = false;
-function runImmediateQueue() {
-  for (let count = 0;!immediateQueue.isEmpty() && !immediateQueueRunning; count++) {
-    if (count > 42) {
-      immediateQueue.clear();
-      throw new Error("Too many immediate-mode recursive updates");
-    }
-    immediateQueueRunning = true;
-    const copy = immediateQueue;
-    immediateQueue = new ReverseSortedSet("prio");
-    try {
-      for (const scope of copy) {
-        scope.queueRun();
-      }
-    } finally {
-      immediateQueueRunning = false;
-    }
-  }
-}
 
 class OnEachScope extends Scope {
   renderer;
@@ -383,22 +357,18 @@ class OnEachScope extends Scope {
     currentScope.cleaners.push(this);
     if (target instanceof Array) {
       for (let i = 0;i < target.length; i++) {
-        if (target[i] !== undefined) {
-          new OnEachItemScope(this, i, false);
-        }
+        new OnEachItemScope(this, i, false);
       }
     } else {
-      for (const [key, value] of getEntries(target)) {
-        if (value !== undefined) {
-          new OnEachItemScope(this, key, false);
-        }
+      for (const key of target instanceof Map ? target.keys() : Object.keys(target)) {
+        new OnEachItemScope(this, key, false);
       }
     }
   }
   getPrecedingNode() {
     return findLastNodeInPrevSiblings(this.prevSibling);
   }
-  onChange(index, newData, oldData) {
+  onChange(index) {
     if (!(this.target instanceof Array) || typeof index === "number")
       this.changedIndexes.add(index);
     queue(this);
@@ -410,16 +380,10 @@ class OnEachScope extends Scope {
       const oldScope = this.byIndex.get(index);
       if (oldScope)
         oldScope.remove();
-      let hasValue;
-      if (this.target instanceof Map) {
-        hasValue = this.target.has(index);
+      if (this.target instanceof Map ? this.target.has(index) : (index in this.target)) {
+        new OnEachItemScope(this, index, true);
       } else {
-        hasValue = this.target[index] !== undefined;
-      }
-      if (!hasValue) {
         this.byIndex.delete(index);
-      } else {
-        new OnEachItemScope(this, index, true);
       }
     }
     topRedrawScope = undefined;
@@ -553,6 +517,15 @@ function addNode(node) {
 }
 var ROOT_SCOPE = new RootScope;
 var currentScope = ROOT_SCOPE;
+function leakScope(func) {
+  const savedScope = currentScope;
+  currentScope = new RootScope;
+  try {
+    return func();
+  } finally {
+    currentScope = savedScope;
+  }
+}
 var ANY_SYMBOL = Symbol("any");
 var TARGET_SYMBOL = Symbol("target");
 var MAP_SIZE_SYMBOL = Symbol("mapSize");
@@ -587,10 +560,11 @@ function onEach(target, render, makeKey) {
   new OnEachScope(target, render, makeKey);
 }
 function isObjEmpty(obj) {
-  for (const k in obj)
+  for (const k of Object.keys(obj))
     return false;
   return true;
 }
+var EMPTY = Symbol("empty");
 function isEmpty(proxied) {
   const target = proxied[TARGET_SYMBOL] || proxied;
   const scope = currentScope;
@@ -610,7 +584,7 @@ function isEmpty(proxied) {
   }
   const result = isObjEmpty(target);
   subscribe(target, ANY_SYMBOL, (index, newData, oldData) => {
-    if (result ? oldData === undefined : newData === undefined)
+    if (result ? oldData === EMPTY : newData === EMPTY)
       queue(scope);
   });
   return result;
@@ -622,14 +596,14 @@ function count(proxied) {
     return ref(proxied, "size");
   const target = proxied[TARGET_SYMBOL] || proxied;
   let cnt = 0;
-  for (const k in target)
+  for (const k of Object.keys(target))
     if (target[k] !== undefined)
       cnt++;
   const result = proxy(cnt);
   subscribe(target, ANY_SYMBOL, (index, newData, oldData) => {
-    if (oldData === newData) {} else if (oldData === undefined)
+    if (oldData === newData) {} else if (oldData === EMPTY)
       result.value = ++cnt;
-    else if (newData === undefined)
+    else if (newData === EMPTY)
       result.value = --cnt;
   });
   return result;
@@ -647,7 +621,7 @@ function defaultEmitHandler(target, index, newData, oldData) {
         if (typeof observer === "function")
           observer(index, newData, oldData);
         else
-          observer.onChange(index, newData, oldData);
+          observer.onChange(index);
       }
     }
   }
@@ -663,25 +637,22 @@ var objectHandler = {
   set(target, prop, newData) {
     if (typeof newData === "object" && newData)
       newData = newData[TARGET_SYMBOL] || newData;
-    const oldData = target[prop];
+    const oldData = target.hasOwnProperty(prop) ? target[prop] : EMPTY;
     if (newData !== oldData) {
       target[prop] = newData;
       emit(target, prop, newData, oldData);
-      runImmediateQueue();
     }
     return true;
   },
   deleteProperty(target, prop) {
-    const old = target[prop];
+    const old = target.hasOwnProperty(prop) ? target[prop] : undefined;
     delete target[prop];
-    emit(target, prop, undefined, old);
-    runImmediateQueue();
+    emit(target, prop, EMPTY, old);
     return true;
   },
   has(target, prop) {
-    const result = prop in target;
     subscribe(target, prop);
-    return result;
+    return target.hasOwnProperty(prop);
   },
   ownKeys(target) {
     subscribe(target, ANY_SYMBOL);
@@ -689,27 +660,31 @@ var objectHandler = {
   }
 };
 function arraySet(target, prop, newData) {
-  if (typeof newData === "object" && newData)
+  if (typeof newData === "object" && newData) {
     newData = newData[TARGET_SYMBOL] || newData;
-  const oldData = target[prop];
+  }
+  let oldData = target[prop];
+  if (oldData === undefined && !target.hasOwnProperty(prop))
+    oldData = EMPTY;
   if (newData !== oldData) {
     const oldLength = target.length;
     if (prop === "length") {
       target.length = newData;
       for (let i = newData;i < oldLength; i++) {
-        emit(target, i, undefined, target[i]);
+        emit(target, i, EMPTY, target[i]);
       }
     } else {
-      const intProp = Number.parseInt(prop);
-      if (intProp.toString() === prop)
-        prop = intProp;
+      if (typeof prop === "string") {
+        const n = 0 | prop;
+        if (String(n) === prop && n >= 0)
+          prop = n;
+      }
       target[prop] = newData;
       emit(target, prop, newData, oldData);
     }
     if (target.length !== oldLength) {
       emit(target, "length", target.length, oldLength);
     }
-    runImmediateQueue();
   }
   return true;
 }
@@ -717,18 +692,27 @@ var arrayHandler = {
   get(target, prop) {
     if (prop === TARGET_SYMBOL)
       return target;
-    let subProp = prop;
-    if (typeof prop !== "symbol") {
-      const intProp = Number.parseInt(prop);
-      if (intProp.toString() === prop)
-        subProp = intProp;
+    if (typeof prop === "string") {
+      const n = 0 | prop;
+      if (String(n) === prop && n >= 0)
+        prop = n;
     }
-    subscribe(target, subProp);
+    subscribe(target, prop);
     return optProxy(target[prop]);
   },
   set: arraySet,
   deleteProperty(target, prop) {
-    return arraySet(target, prop, undefined);
+    if (typeof prop === "string") {
+      const n = 0 | prop;
+      if (String(n) === prop && n >= 0)
+        prop = n;
+    }
+    let oldData = target[prop];
+    if (oldData === undefined && !target.hasOwnProperty(prop))
+      oldData = EMPTY;
+    delete target[prop];
+    emit(target, prop, EMPTY, oldData);
+    return true;
   }
 };
 function wrapIteratorSingle(iterator) {
@@ -773,30 +757,35 @@ var mapMethodHandlers = {
   },
   set(key, newData) {
     const target = this[TARGET_SYMBOL];
-    if (typeof key === "object" && key)
+    if (typeof key === "object" && key) {
       key = key[TARGET_SYMBOL] || key;
-    if (typeof newData === "object" && newData)
+    }
+    if (typeof newData === "object" && newData) {
       newData = newData[TARGET_SYMBOL] || newData;
-    const oldData = target.get(key);
+    }
+    let oldData = target.get(key);
+    if (oldData === undefined && !target.has(key))
+      oldData = EMPTY;
     if (newData !== oldData) {
       const oldSize = target.size;
       target.set(key, newData);
       emit(target, key, newData, oldData);
       emit(target, MAP_SIZE_SYMBOL, target.size, oldSize);
-      runImmediateQueue();
     }
     return this;
   },
   delete(key) {
     const target = this[TARGET_SYMBOL];
-    if (typeof key === "object" && key)
+    if (typeof key === "object" && key) {
       key = key[TARGET_SYMBOL] || key;
-    const oldData = target.get(key);
+    }
+    let oldData = target.get(key);
+    if (oldData === undefined && !target.has(key))
+      oldData = EMPTY;
     const result = target.delete(key);
     if (result) {
-      emit(target, key, undefined, oldData);
+      emit(target, key, EMPTY, oldData);
       emit(target, MAP_SIZE_SYMBOL, target.size, target.size + 1);
-      runImmediateQueue();
     }
     return result;
   },
@@ -804,17 +793,16 @@ var mapMethodHandlers = {
     const target = this[TARGET_SYMBOL];
     const oldSize = target.size;
     for (const key of target.keys()) {
-      const oldData = target.get(key);
-      emit(target, key, undefined, oldData);
+      emit(target, key, undefined, target.get(key));
     }
     target.clear();
     emit(target, MAP_SIZE_SYMBOL, 0, oldSize);
-    runImmediateQueue();
   },
   has(key) {
     const target = this[TARGET_SYMBOL];
-    if (typeof key === "object" && key)
+    if (typeof key === "object" && key) {
       key = key[TARGET_SYMBOL] || key;
+    }
     subscribe(target, key);
     return target.has(key);
   },
@@ -843,15 +831,14 @@ var mapHandler = {
   get(target, prop) {
     if (prop === TARGET_SYMBOL)
       return target;
-    if (prop in mapMethodHandlers) {
+    if (mapMethodHandlers.hasOwnProperty(prop)) {
       return mapMethodHandlers[prop];
     }
     if (prop === "size") {
       subscribe(target, MAP_SIZE_SYMBOL);
       return target.size;
     }
-    subscribe(target, prop);
-    return optProxy(target[prop]);
+    return target[prop];
   }
 };
 var proxyMap = new WeakMap;
@@ -886,31 +873,31 @@ function destroyWithClass(element, cls) {
   element.classList.add(...classes);
   setTimeout(() => element.remove(), 2000);
 }
-function copy(dst, src, flags = 0) {
-  copyRecurse(dst, src, flags);
-  runImmediateQueue();
-}
-var MERGE = 1;
-var SHALLOW = 2;
-var COPY_SUBSCRIBE = 32;
-var COPY_EMIT = 64;
-function clone(src, flags = 0) {
-  let dst;
-  if (src instanceof Map) {
-    dst = new Map;
-  } else {
-    dst = Object.create(Object.getPrototypeOf(src));
-  }
-  copyRecurse(dst, src, flags);
-  return dst;
+function copy(a, b, c) {
+  if (arguments.length > 2)
+    return copySet(a, b, c, 0);
+  return copyRecursive(a, b, 0);
 }
-function getEntries(subject) {
-  return subject instanceof Map ? subject.entries() : Object.entries(subject);
+function copySet(dst, dstKey, src, flags) {
+  let dstVal = peek(dst, dstKey);
+  if (src === dstVal)
+    return false;
+  if (typeof dstVal === "object" && dstVal && typeof src === "object" && src && dstVal.constructor === src.constructor) {
+    return copyRecursive(dstVal, src, flags);
+  }
+  src = clone(src);
+  if (dst instanceof Map)
+    dst.set(dstKey, src);
+  else
+    dst[dstKey] = clone(src);
+  return true;
 }
-function getKeys(subject) {
-  return subject instanceof Map ? subject.keys() : Object.keys(subject);
+function merge(a, b, c) {
+  if (arguments.length > 2)
+    return copySet(a, b, c, MERGE);
+  return copyRecursive(a, b, MERGE);
 }
-function copyRecurse(dst, src, flags) {
+function copyRecursive(dst, src, flags) {
   let unproxied = dst[TARGET_SYMBOL];
   if (unproxied) {
     dst = unproxied;
@@ -924,87 +911,122 @@ function copyRecurse(dst, src, flags) {
   }
   if (flags & COPY_SUBSCRIBE)
     subscribe(src, ANY_SYMBOL);
-  if (src instanceof Array) {
-    if (!(dst instanceof Array))
-      throw new Error("Cannot copy array into object");
+  let changed = false;
+  if (src instanceof Array && dst instanceof Array) {
     const dstLen = dst.length;
     const srcLen = src.length;
-    for (let i = 0;i < srcLen; i++) {
-      copyValue(dst, i, src[i], flags);
+    for (let index = 0;index < srcLen; index++) {
+      let dstValue = dst[index];
+      if (dstValue === undefined && !dst.hasOwnProperty(index))
+        dstValue = EMPTY;
+      let srcValue = src[index];
+      if (srcValue === undefined && !src.hasOwnProperty(index)) {
+        delete dst[index];
+        if (flags & COPY_EMIT)
+          emit(dst, index, EMPTY, dstValue);
+        changed = true;
+      } else if (dstValue !== srcValue) {
+        if (srcValue && typeof srcValue === "object") {
+          if (typeof dstValue === "object" && dstValue && srcValue.constructor === dstValue.constructor) {
+            changed = copyRecursive(dstValue, srcValue, flags) || changed;
+            continue;
+          }
+          srcValue = clone(srcValue);
+        }
+        dst[index] = srcValue;
+        if (flags & COPY_EMIT)
+          emit(dst, index, srcValue, dstValue);
+        changed = true;
+      }
     }
     if (srcLen !== dstLen) {
       if (flags & COPY_EMIT) {
         for (let i = srcLen;i < dstLen; i++) {
           const old = dst[i];
-          dst[i] = undefined;
-          emit(dst, i, undefined, old);
+          delete dst[i];
+          emit(dst, i, EMPTY, old);
         }
         dst.length = srcLen;
         emit(dst, "length", srcLen, dstLen);
       } else {
         dst.length = srcLen;
       }
+      changed = true;
     }
-  } else {
-    for (const [key, value] of getEntries(src)) {
-      copyValue(dst, key, value, flags);
+  } else if (src instanceof Map && dst instanceof Map) {
+    for (const key of src.keys()) {
+      let srcValue = src.get(key);
+      let dstValue = dst.get(key);
+      if (dstValue === undefined && !dst.has(key))
+        dstValue = EMPTY;
+      if (dstValue !== srcValue) {
+        if (srcValue && typeof srcValue === "object") {
+          if (typeof dstValue === "object" && dstValue && srcValue.constructor === dstValue.constructor) {
+            changed = copyRecursive(dstValue, srcValue, flags) || changed;
+            continue;
+          }
+          srcValue = clone(srcValue);
+        }
+        dst.set(key, srcValue);
+        if (flags & COPY_EMIT)
+          emit(dst, key, srcValue, dstValue);
+        changed = true;
+      }
     }
     if (!(flags & MERGE)) {
-      if (src instanceof Map) {
-        for (const key of getKeys(dst)) {
-          if (!src.has(key)) {
-            deleteKey(dst, key, flags);
+      for (const k of dst.keys()) {
+        if (!src.has(k)) {
+          const old = dst.get(k);
+          dst.delete(k);
+          if (flags & COPY_EMIT) {
+            emit(dst, k, undefined, old);
           }
+          changed = true;
         }
-      } else {
-        for (const key of getKeys(dst)) {
-          if (!(key in src)) {
-            deleteKey(dst, key, flags);
+      }
+    }
+  } else if (src.constructor === dst.constructor) {
+    for (const key of Object.keys(src)) {
+      let srcValue = src[key];
+      const dstValue = dst.hasOwnProperty(key) ? dst[key] : EMPTY;
+      if (dstValue !== srcValue) {
+        if (srcValue && typeof srcValue === "object") {
+          if (typeof dstValue === "object" && dstValue && srcValue.constructor === dstValue.constructor) {
+            changed = copyRecursive(dstValue, srcValue, flags) || changed;
+            continue;
           }
+          srcValue = clone(srcValue);
+        }
+        dst[key] = srcValue;
+        if (flags & COPY_EMIT)
+          emit(dst, key, srcValue, dstValue);
+        changed = true;
+      }
+    }
+    if (!(flags & MERGE)) {
+      for (const k of Object.keys(dst)) {
+        if (!src.hasOwnProperty(k)) {
+          const old = dst[k];
+          delete dst[k];
+          if (flags & COPY_EMIT && old !== undefined) {
+            emit(dst, k, undefined, old);
+          }
+          changed = true;
         }
       }
     }
-  }
-}
-function deleteKey(dst, key, flags) {
-  let old;
-  if (dst instanceof Map) {
-    old = dst.get(key);
-    dst.delete(key);
   } else {
-    old = dst[key];
-    delete dst[key];
-  }
-  if (flags & COPY_EMIT && old !== undefined) {
-    emit(dst, key, undefined, old);
+    throw new Error(`Incompatible or non-object types: ${src?.constructor?.name || typeof src} vs ${dst?.constructor?.name || typeof dst}`);
   }
+  return changed;
 }
-function copyValue(dst, index, srcValue, flags) {
-  const dstValue = dst instanceof Map ? dst.get(index) : dst[index];
-  if (srcValue !== dstValue) {
-    if (srcValue && dstValue && typeof srcValue === "object" && typeof dstValue === "object" && (srcValue.constructor === dstValue.constructor || flags & MERGE && dstValue instanceof Array)) {
-      copyRecurse(dstValue, srcValue, flags);
-      return;
-    }
-    if (!(flags & SHALLOW) && srcValue && typeof srcValue === "object") {
-      const copy2 = Object.create(Object.getPrototypeOf(srcValue));
-      copyRecurse(copy2, srcValue, 0);
-      srcValue = copy2;
-    }
-    if (dst instanceof Map) {
-      if (flags & MERGE && srcValue == null)
-        dst.delete(index);
-      else
-        dst.set(index, srcValue);
-    } else {
-      if (flags & MERGE && srcValue == null)
-        delete dst[index];
-      else
-        dst[index] = srcValue;
-    }
-    if (flags & COPY_EMIT)
-      emit(dst, index, srcValue, dstValue);
-  }
+var MERGE = 1;
+var COPY_SUBSCRIBE = 32;
+var COPY_EMIT = 64;
+function clone(src) {
+  const copied = Array.isArray(src) ? [] : src instanceof Map ? new Map : Object.create(Object.getPrototypeOf(src));
+  copyRecursive(copied, src, MERGE);
+  return copied;
 }
 var refHandler = {
   get(target, prop) {
@@ -1062,7 +1084,7 @@ function applyBind(el, target) {
         throw new Error(`SELECT has no '${target.value}' OPTION (yet)`);
     };
   }
-  observe(onProxyChange);
+  derive(onProxyChange);
   el.addEventListener("input", onInputChange);
   clean(() => {
     el.removeEventListener("input", onInputChange);
@@ -1096,11 +1118,6 @@ var SPECIAL_PROPS = {
   },
   text: (value) => {
     addNode(document.createTextNode(value));
-  },
-  element: (value) => {
-    console.log("Aberdeen: $({element: myElement}) is deprecated, use $(myElement) instead");
-    addNode(value);
-    SPECIAL_PROPS.element = addNode;
   }
 };
 function $(...args) {
@@ -1175,7 +1192,7 @@ function $(...args) {
           break;
         }
       } else {
-        for (const key in arg) {
+        for (const key of Object.keys(arg)) {
           const val = arg[key];
           applyArg(key, val);
         }
@@ -1205,7 +1222,7 @@ function insertCss(style, global = false) {
 function styleToCss(style, prefix) {
   let props = "";
   let rules = "";
-  for (const kOr in style) {
+  for (const kOr of Object.keys(style)) {
     const v = style[kOr];
     for (const k of kOr.split(/, ?/g)) {
       if (v && typeof v === "object") {
@@ -1271,12 +1288,9 @@ function getParentElement() {
 function clean(cleaner) {
   currentScope.cleaners.push(cleaner);
 }
-function observe(func) {
+function derive(func) {
   return new ResultScope(currentScope.parentElement, func).result;
 }
-function immediateObserve(func) {
-  new ImmediateScope(currentScope.parentElement, func);
-}
 function mount(parentElement, func) {
   new MountScope(parentElement, func);
 }
@@ -1284,10 +1298,14 @@ function unmountAll() {
   ROOT_SCOPE.remove();
   cssCount = 0;
 }
-function peek(func) {
+function peek(target, key) {
   peeking++;
   try {
-    return func();
+    if (arguments.length === 1) {
+      return target();
+    } else {
+      return target instanceof Map ? target.get(key) : target[key];
+    }
   } finally {
     peeking--;
   }
@@ -1324,10 +1342,10 @@ function multiMap(source, func) {
   onEach(source, (item, key) => {
     const pairs = func(item, key);
     if (pairs) {
-      for (const key2 in pairs)
+      for (const key2 of Object.keys(pairs))
         out[key2] = pairs[key2];
       clean(() => {
-        for (const key2 in pairs)
+        for (const key2 of Object.keys(pairs))
           delete out[key2];
       });
     }
@@ -1418,25 +1436,24 @@ export {
   peek,
   partition,
   onEach,
-  observe,
   multiMap,
   mount,
+  merge,
   map,
+  leakScope,
   isEmpty,
   invertString,
   insertCss,
-  immediateObserve,
   getParentElement,
   dump,
+  derive,
   defaultEmitHandler,
   count,
   copy,
   clone,
   clean,
-  SHALLOW,
-  MERGE,
   $
 };
 
-//# debugId=8143A247906C19B564756E2164756E21
+//# debugId=37C620855881B81F64756E2164756E21
 //# sourceMappingURL=aberdeen.js.map