ember-source 5.12.0-beta.2 → 5.12.0

package/dist/packages/@glimmer/reference/index.js

@@ -3,14 +3,11 @@ import { expect, isDict, EMPTY_ARRAY, isObject } from '../util/index.js';
 import { CONSTANT_TAG, validateTag, track, valueForTag, consumeTag, dirtyTag as DIRTY_TAG, createTag, INITIAL } from '../validator/index.js';
 import { isDevelopingApp } from '@embroider/macros';
 
-const REFERENCE = Symbol('REFERENCE');
-const CONSTANT = 0;
-const COMPUTE = 1;
-const UNBOUND = 2;
-const INVOKABLE = 3;
+const REFERENCE = Symbol("REFERENCE"),
+  COMPUTE = 1,
+  UNBOUND = 2;
 
 //////////
-
 class ReferenceImpl {
   [REFERENCE];
   tag = null;
@@ -26,229 +23,113 @@ class ReferenceImpl {
 }
 function createPrimitiveRef(value) {
   const ref = new ReferenceImpl(UNBOUND);
-  ref.tag = CONSTANT_TAG;
-  ref.lastValue = value;
-  if (isDevelopingApp()) {
-    ref.debugLabel = String(value);
-  }
-  return ref;
+  return ref.tag = CONSTANT_TAG, ref.lastValue = value, isDevelopingApp() && (ref.debugLabel = String(value)), ref;
 }
-const UNDEFINED_REFERENCE = createPrimitiveRef(undefined);
-const NULL_REFERENCE = createPrimitiveRef(null);
-const TRUE_REFERENCE = createPrimitiveRef(true);
-const FALSE_REFERENCE = createPrimitiveRef(false);
+const UNDEFINED_REFERENCE = createPrimitiveRef(void 0),
+  NULL_REFERENCE = createPrimitiveRef(null),
+  TRUE_REFERENCE = createPrimitiveRef(!0),
+  FALSE_REFERENCE = createPrimitiveRef(!1);
 function createConstRef(value, debugLabel) {
-  const ref = new ReferenceImpl(CONSTANT);
-  ref.lastValue = value;
-  ref.tag = CONSTANT_TAG;
-  if (isDevelopingApp()) {
-    ref.debugLabel = debugLabel;
-  }
-  return ref;
+  const ref = new ReferenceImpl(0);
+  return ref.lastValue = value, ref.tag = CONSTANT_TAG, isDevelopingApp() && (ref.debugLabel = debugLabel), ref;
 }
 function createUnboundRef(value, debugLabel) {
   const ref = new ReferenceImpl(UNBOUND);
-  ref.lastValue = value;
-  ref.tag = CONSTANT_TAG;
-  if (isDevelopingApp()) {
-    ref.debugLabel = debugLabel;
-  }
-  return ref;
+  return ref.lastValue = value, ref.tag = CONSTANT_TAG, isDevelopingApp() && (ref.debugLabel = debugLabel), ref;
 }
-function createComputeRef(compute, update = null, debugLabel = 'unknown') {
+function createComputeRef(compute, update = null, debugLabel = "unknown") {
   const ref = new ReferenceImpl(COMPUTE);
-  ref.compute = compute;
-  ref.update = update;
-  if (isDevelopingApp()) {
-    ref.debugLabel = `(result of a \`${debugLabel}\` helper)`;
-  }
-  return ref;
+  return ref.compute = compute, ref.update = update, isDevelopingApp() && (ref.debugLabel = `(result of a \`${debugLabel}\` helper)`), ref;
 }
 function createReadOnlyRef(ref) {
-  if (!isUpdatableRef(ref)) return ref;
-  return createComputeRef(() => valueForRef(ref), null, ref.debugLabel);
+  return isUpdatableRef(ref) ? createComputeRef(() => valueForRef(ref), null, ref.debugLabel) : ref;
 }
 function isInvokableRef(ref) {
-  return ref[REFERENCE] === INVOKABLE;
+  return 3 === ref[REFERENCE];
 }
 function createInvokableRef(inner) {
   const ref = createComputeRef(() => valueForRef(inner), value => updateRef(inner, value));
-  ref.debugLabel = inner.debugLabel;
-  ref[REFERENCE] = INVOKABLE;
-  return ref;
+  return ref.debugLabel = inner.debugLabel, ref[REFERENCE] = 3, ref;
 }
 function isConstRef(_ref) {
-  const ref = _ref;
-  return ref.tag === CONSTANT_TAG;
+  return _ref.tag === CONSTANT_TAG;
 }
 function isUpdatableRef(_ref) {
-  const ref = _ref;
-  return ref.update !== null;
+  return null !== _ref.update;
 }
 function valueForRef(_ref) {
   const ref = _ref;
   let {
-    tag
+    tag: tag
   } = ref;
-  if (tag === CONSTANT_TAG) {
-    return ref.lastValue;
-  }
+  if (tag === CONSTANT_TAG) return ref.lastValue;
   const {
-    lastRevision
+    lastRevision: lastRevision
   } = ref;
   let lastValue;
-  if (tag === null || !validateTag(tag, lastRevision)) {
+  if (null !== tag && validateTag(tag, lastRevision)) lastValue = ref.lastValue;else {
     const {
-      compute
-    } = ref;
-    const newTag = track(() => {
-      lastValue = ref.lastValue = compute();
-    }, isDevelopingApp() && ref.debugLabel);
-    tag = ref.tag = newTag;
-    ref.lastRevision = valueForTag(newTag);
-  } else {
-    lastValue = ref.lastValue;
+        compute: compute
+      } = ref,
+      newTag = track(() => {
+        lastValue = ref.lastValue = compute();
+      }, isDevelopingApp() && ref.debugLabel);
+    tag = ref.tag = newTag, ref.lastRevision = valueForTag(newTag);
   }
-  consumeTag(tag);
-  return lastValue;
+  return consumeTag(tag), lastValue;
 }
 function updateRef(_ref, value) {
-  const ref = _ref;
-  const update = expect(ref.update, 'called update on a non-updatable reference');
-  update(value);
+  expect(_ref.update, "called update on a non-updatable reference")(value);
 }
 function childRefFor(_parentRef, path) {
-  const parentRef = _parentRef;
-  const type = parentRef[REFERENCE];
-  let children = parentRef.children;
-  let child;
-  if (children === null) {
-    children = parentRef.children = new Map();
-  } else {
-    child = children.get(path);
-    if (child !== undefined) {
-      return child;
-    }
-  }
+  const parentRef = _parentRef,
+    type = parentRef[REFERENCE];
+  let child,
+    children = parentRef.children;
+  if (null === children) children = parentRef.children = new Map();else if (child = children.get(path), void 0 !== child) return child;
   if (type === UNBOUND) {
     const parent = valueForRef(parentRef);
-    if (isDict(parent)) {
-      child = createUnboundRef(parent[path], isDevelopingApp() && `${parentRef.debugLabel}.${path}`);
-    } else {
-      child = UNDEFINED_REFERENCE;
-    }
-  } else {
-    child = createComputeRef(() => {
-      const parent = valueForRef(parentRef);
-      if (isDict(parent)) {
-        return getProp(parent, path);
-      }
-    }, val => {
-      const parent = valueForRef(parentRef);
-      if (isDict(parent)) {
-        return setProp(parent, path, val);
-      }
-    });
-    if (isDevelopingApp()) {
-      child.debugLabel = `${parentRef.debugLabel}.${path}`;
-    }
-  }
-  children.set(path, child);
-  return child;
+    child = isDict(parent) ? createUnboundRef(parent[path], isDevelopingApp() && `${parentRef.debugLabel}.${path}`) : UNDEFINED_REFERENCE;
+  } else child = createComputeRef(() => {
+    const parent = valueForRef(parentRef);
+    if (isDict(parent)) return getProp(parent, path);
+  }, val => {
+    const parent = valueForRef(parentRef);
+    if (isDict(parent)) return setProp(parent, path, val);
+  }), isDevelopingApp() && (child.debugLabel = `${parentRef.debugLabel}.${path}`);
+  return children.set(path, child), child;
 }
 function childRefFromParts(root, parts) {
   let reference = root;
-  for (const part of parts) {
-    reference = childRefFor(reference, part);
-  }
+  for (const part of parts) reference = childRefFor(reference, part);
   return reference;
 }
 let createDebugAliasRef;
-if (isDevelopingApp()) {
-  createDebugAliasRef = (debugLabel, inner) => {
-    const update = isUpdatableRef(inner) ? value => updateRef(inner, value) : null;
-    const ref = createComputeRef(() => valueForRef(inner), update);
-    ref[REFERENCE] = inner[REFERENCE];
-    ref.debugLabel = debugLabel;
-    return ref;
-  };
-}
-const NULL_IDENTITY = {};
-const KEY = (_, index) => index;
-const INDEX = (_, index) => String(index);
-const IDENTITY = item => {
-  if (item === null) {
-    // Returning null as an identity will cause failures since the iterator
-    // can't tell that it's actually supposed to be null
-    return NULL_IDENTITY;
-  }
-  return item;
-};
-function keyForPath(path) {
-  if (isDevelopingApp() && path[0] === '@') {
-    throw new Error(`invalid keypath: '${path}', valid keys: @index, @identity, or a path`);
-  }
-  return uniqueKeyFor(item => getPath(item, path));
-}
-function makeKeyFor(key) {
-  switch (key) {
-    case '@key':
-      return uniqueKeyFor(KEY);
-    case '@index':
-      return uniqueKeyFor(INDEX);
-    case '@identity':
-      return uniqueKeyFor(IDENTITY);
-    default:
-      return keyForPath(key);
-  }
-}
+isDevelopingApp() && (createDebugAliasRef = (debugLabel, inner) => {
+  const ref = createComputeRef(() => valueForRef(inner), isUpdatableRef(inner) ? value => updateRef(inner, value) : null);
+  return ref[REFERENCE] = inner[REFERENCE], ref.debugLabel = debugLabel, ref;
+});
+const NULL_IDENTITY = {},
+  KEY = (_, index) => index,
+  INDEX = (_, index) => String(index),
+  IDENTITY = item => null === item ? NULL_IDENTITY : item;
 class WeakMapWithPrimitives {
   _weakMap;
   _primitiveMap;
   get weakMap() {
-    if (this._weakMap === undefined) {
-      this._weakMap = new WeakMap();
-    }
-    return this._weakMap;
+    return void 0 === this._weakMap && (this._weakMap = new WeakMap()), this._weakMap;
   }
   get primitiveMap() {
-    if (this._primitiveMap === undefined) {
-      this._primitiveMap = new Map();
-    }
-    return this._primitiveMap;
+    return void 0 === this._primitiveMap && (this._primitiveMap = new Map()), this._primitiveMap;
   }
   set(key, value) {
-    if (isObject(key)) {
-      this.weakMap.set(key, value);
-    } else {
-      this.primitiveMap.set(key, value);
-    }
+    isObject(key) ? this.weakMap.set(key, value) : this.primitiveMap.set(key, value);
   }
   get(key) {
-    if (isObject(key)) {
-      return this.weakMap.get(key);
-    } else {
-      return this.primitiveMap.get(key);
-    }
+    return isObject(key) ? this.weakMap.get(key) : this.primitiveMap.get(key);
   }
 }
 const IDENTITIES = new WeakMapWithPrimitives();
-function identityForNthOccurence(value, count) {
-  let identities = IDENTITIES.get(value);
-  if (identities === undefined) {
-    identities = [];
-    IDENTITIES.set(value, identities);
-  }
-  let identity = identities[count];
-  if (identity === undefined) {
-    identity = {
-      value,
-      count
-    };
-    identities[count] = identity;
-  }
-  return identity;
-}
 
 /**
  * When iterating over a list, it's possible that an item with the same unique
@@ -268,100 +149,91 @@ function identityForNthOccurence(value, count) {
 function uniqueKeyFor(keyFor) {
   let seen = new WeakMapWithPrimitives();
   return (value, memo) => {
-    let key = keyFor(value, memo);
-    let count = seen.get(key) || 0;
-    seen.set(key, count + 1);
-    if (count === 0) {
-      return key;
-    }
-    return identityForNthOccurence(key, count);
+    let key = keyFor(value, memo),
+      count = seen.get(key) || 0;
+    return seen.set(key, count + 1), 0 === count ? key : function (value, count) {
+      let identities = IDENTITIES.get(value);
+      void 0 === identities && (identities = [], IDENTITIES.set(value, identities));
+      let identity = identities[count];
+      return void 0 === identity && (identity = {
+        value: value,
+        count: count
+      }, identities[count] = identity), identity;
+    }(key, count);
   };
 }
 function createIteratorRef(listRef, key) {
   return createComputeRef(() => {
-    let iterable = valueForRef(listRef);
-    let keyFor = makeKeyFor(key);
-    if (Array.isArray(iterable)) {
-      return new ArrayIterator(iterable, keyFor);
-    }
+    let iterable = valueForRef(listRef),
+      keyFor = function (key) {
+        switch (key) {
+          case "@key":
+            return uniqueKeyFor(KEY);
+          case "@index":
+            return uniqueKeyFor(INDEX);
+          case "@identity":
+            return uniqueKeyFor(IDENTITY);
+          default:
+            return function (path) {
+              if (isDevelopingApp() && "@" === path[0]) throw new Error(`invalid keypath: '${path}', valid keys: @index, @identity, or a path`);
+              return uniqueKeyFor(item => getPath(item, path));
+            }(key);
+        }
+      }(key);
+    if (Array.isArray(iterable)) return new ArrayIterator(iterable, keyFor);
     let maybeIterator = toIterator(iterable);
-    if (maybeIterator === null) {
-      return new ArrayIterator(EMPTY_ARRAY, () => null);
-    }
-    return new IteratorWrapper(maybeIterator, keyFor);
+    return null === maybeIterator ? new ArrayIterator(EMPTY_ARRAY, () => null) : new IteratorWrapper(maybeIterator, keyFor);
   });
 }
 function createIteratorItemRef(_value) {
-  let value = _value;
-  let tag = createTag();
-  return createComputeRef(() => {
-    consumeTag(tag);
-    return value;
-  }, newValue => {
-    if (value !== newValue) {
-      value = newValue;
-      DIRTY_TAG(tag);
-    }
+  let value = _value,
+    tag = createTag();
+  return createComputeRef(() => (consumeTag(tag), value), newValue => {
+    value !== newValue && (value = newValue, DIRTY_TAG(tag));
   });
 }
 class IteratorWrapper {
   constructor(inner, keyFor) {
-    this.inner = inner;
-    this.keyFor = keyFor;
+    this.inner = inner, this.keyFor = keyFor;
   }
   isEmpty() {
     return this.inner.isEmpty();
   }
   next() {
     let nextValue = this.inner.next();
-    if (nextValue !== null) {
-      nextValue.key = this.keyFor(nextValue.value, nextValue.memo);
-    }
-    return nextValue;
+    return null !== nextValue && (nextValue.key = this.keyFor(nextValue.value, nextValue.memo)), nextValue;
   }
 }
 class ArrayIterator {
   current;
   pos = 0;
   constructor(iterator, keyFor) {
-    this.iterator = iterator;
-    this.keyFor = keyFor;
-    if (iterator.length === 0) {
-      this.current = {
-        kind: 'empty'
-      };
-    } else {
-      this.current = {
-        kind: 'first',
-        value: iterator[this.pos]
-      };
-    }
+    this.iterator = iterator, this.keyFor = keyFor, 0 === iterator.length ? this.current = {
+      kind: "empty"
+    } : this.current = {
+      kind: "first",
+      value: iterator[this.pos]
+    };
   }
   isEmpty() {
-    return this.current.kind === 'empty';
+    return "empty" === this.current.kind;
   }
   next() {
-    let value;
-    let current = this.current;
-    if (current.kind === 'first') {
-      this.current = {
-        kind: 'progress'
-      };
-      value = current.value;
-    } else if (this.pos >= this.iterator.length - 1) {
-      return null;
-    } else {
+    let value,
+      current = this.current;
+    if ("first" === current.kind) this.current = {
+      kind: "progress"
+    }, value = current.value;else {
+      if (this.pos >= this.iterator.length - 1) return null;
       value = this.iterator[++this.pos];
     }
     let {
-      keyFor
+      keyFor: keyFor
     } = this;
-    let key = keyFor(value, this.pos);
-    let memo = this.pos;
     return {
-      key,
-      value,
-      memo
+      key: keyFor(value, this.pos),
+      value: value,
+      memo: this.pos
     };
   }
 }