ember-source 7.1.0-alpha.4 → 7.1.0-alpha.5

package/dist/prod/packages/shared-chunks/{injected_property-CTVs5FPh.js → injected_property-D9B-fPiH.js}

@@ -1,7 +1,7 @@
 import { getOwner } from '../@ember/-internals/owner/index.js';
-import '../@ember/-internals/environment/index.js';
-import { c as computed, d as defineProperty } from './namespace_search-Dcdalhj6.js';
-import { i as isElementDescriptor } from './decorator-BdDDBUd2.js';
+import './env-DXxsTFkM.js';
+import { c as computed, d as defineProperty } from './computed-2Udcmflw.js';
+import { i as isElementDescriptor } from './decorator-DBCISop4.js';
 
 let DEBUG_INJECTION_FUNCTIONS;
 

package/dist/prod/packages/shared-chunks/intern-zquhAEIg.js

@@ -0,0 +1,51 @@
+/**
+  Strongly hint runtimes to intern the provided string.
+
+  When do I need to use this function?
+
+  For the most part, never. Pre-mature optimization is bad, and often the
+  runtime does exactly what you need it to, and more often the trade-off isn't
+  worth it.
+
+  Why?
+
+  Runtimes store strings in at least 2 different representations:
+  Ropes and Symbols (interned strings). The Rope provides a memory efficient
+  data-structure for strings created from concatenation or some other string
+  manipulation like splitting.
+
+  Unfortunately checking equality of different ropes can be quite costly as
+  runtimes must resort to clever string comparison algorithms. These
+  algorithms typically cost in proportion to the length of the string.
+  Luckily, this is where the Symbols (interned strings) shine. As Symbols are
+  unique by their string content, equality checks can be done by pointer
+  comparison.
+
+  How do I know if my string is a rope or symbol?
+
+  Typically (warning general sweeping statement, but truthy in runtimes at
+  present) static strings created as part of the JS source are interned.
+  Strings often used for comparisons can be interned at runtime if some
+  criteria are met.  One of these criteria can be the size of the entire rope.
+  For example, in chrome 38 a rope longer then 12 characters will not
+  intern, nor will segments of that rope.
+
+  Some numbers: http://jsperf.com/eval-vs-keys/8
+
+  Known Trick™
+
+  @private
+  @return {String} interned version of the provided string
+*/
+function intern(str) {
+  let obj = Object.create(null);
+  obj[str] = 1;
+  for (let key in obj) {
+    if (key === str) {
+      return key;
+    }
+  }
+  return str;
+}
+
+export { intern as i };

package/dist/prod/packages/shared-chunks/internal-DidurjJB.js

@@ -0,0 +1,137 @@
+import { setOwner } from '../@ember/-internals/owner/index.js';
+import { g as guidFor } from './guid-Cbq2sNV_.js';
+import './env-DXxsTFkM.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+import { s as setComponentTemplate } from './template-Dc_cBOoX.js';
+import { s as setInternalComponentManager } from './api-zh_k31vb.js';
+import { v as valueForRef, c as createConstRef } from './reference-BshxG6wn.js';
+import { u as untrack } from './cache-BIlOoPA7.js';
+
+function NOOP() {}
+class InternalComponent {
+  // Override this
+  static toString() {
+    return 'internal component';
+  }
+  constructor(owner, args, caller) {
+    this.owner = owner;
+    this.args = args;
+    this.caller = caller;
+    setOwner(this, owner);
+  }
+
+  /**
+   * The default HTML id attribute. We don't really _need_ one, this is just
+   * added for compatibility as it's hard to tell if people rely on it being
+   * present, and it doens't really hurt.
+   *
+   * However, don't rely on this internally, like passing it to `getElementId`.
+   * This can be (and often is) overriden by passing an `id` attribute on the
+   * invocation, which shadows this default id via `...attributes`.
+   */
+  get id() {
+    return guidFor(this);
+  }
+
+  /**
+   * The default HTML class attribute. Similar to the above, we don't _need_
+   * them, they are just added for compatibility as it's similarly hard to tell
+   * if people rely on it in their CSS etc, and it doens't really hurt.
+   */
+  get class() {
+    return 'ember-view';
+  }
+  validateArguments() {
+    for (let name of Object.keys(this.args.named)) {
+      if (!this.isSupportedArgument(name)) {
+        this.onUnsupportedArgument(name);
+      }
+    }
+  }
+  named(name) {
+    let ref = this.args.named[name];
+    return ref ? valueForRef(ref) : undefined;
+  }
+  positional(index) {
+    let ref = this.args.positional[index];
+    return ref ? valueForRef(ref) : undefined;
+  }
+  listenerFor(name) {
+    let listener = this.named(name);
+    if (listener) {
+      return listener;
+    } else {
+      return NOOP;
+    }
+  }
+  isSupportedArgument(_name) {
+    return false;
+  }
+  onUnsupportedArgument(_name) {}
+  toString() {
+    return `<${this.constructor}:${guidFor(this)}>`;
+  }
+}
+const OPAQUE_CONSTRUCTOR_MAP = new WeakMap();
+function opaquify(constructor, template) {
+  let _opaque = {
+    // Factory interface
+    create() {
+      throw assert('Use constructor instead of create');
+    },
+    toString() {
+      return constructor.toString();
+    }
+  };
+  let opaque = _opaque;
+  OPAQUE_CONSTRUCTOR_MAP.set(opaque, constructor);
+  setInternalComponentManager(INTERNAL_COMPONENT_MANAGER, opaque);
+  setComponentTemplate(template, opaque);
+  return opaque;
+}
+function deopaquify(opaque) {
+  let constructor = OPAQUE_CONSTRUCTOR_MAP.get(opaque);
+  return constructor;
+}
+const CAPABILITIES = {
+  dynamicLayout: false,
+  dynamicTag: false,
+  prepareArgs: false,
+  createArgs: true,
+  attributeHook: false,
+  elementHook: false,
+  createCaller: true,
+  dynamicScope: false,
+  updateHook: false,
+  createInstance: true,
+  wrapped: false,
+  willDestroy: false,
+  hasSubOwner: false
+};
+class InternalManager {
+  getCapabilities() {
+    return CAPABILITIES;
+  }
+  create(owner, definition, args, _env, _dynamicScope, caller) {
+    let ComponentClass = deopaquify(definition);
+    let instance = new ComponentClass(owner, args.capture(), valueForRef(caller));
+    untrack(instance['validateArguments'].bind(instance));
+    return instance;
+  }
+  didCreate() {}
+  didUpdate() {}
+  didRenderLayout() {}
+  didUpdateLayout() {}
+  getDebugName(definition) {
+    return definition.toString();
+  }
+  getSelf(instance) {
+    return createConstRef(instance);
+  }
+  getDestroyable(instance) {
+    return instance;
+  }
+}
+const INTERNAL_COMPONENT_MANAGER = new InternalManager();
+
+export { InternalComponent as I, opaquify as o };

package/dist/prod/packages/shared-chunks/internal-helper-DIbr1RgC.js

@@ -0,0 +1,7 @@
+import { j as setInternalHelperManager } from './api-zh_k31vb.js';
+
+function internalHelper(helper) {
+  return setInternalHelperManager(helper, {});
+}
+
+export { internalHelper as i };

package/dist/prod/packages/shared-chunks/{neq-BqdovTuC.js → invoke-Dr_CRwA_.js}

@@ -1,19 +1,8 @@
 import { associateDestroyableChild } from '../@glimmer/destroyable/index.js';
-import { g as getInternalHelperManager, b as hasValue, c as hasDestroyable } from './api-B5UrgITK.js';
-import { createCache, getValue } from '../@glimmer/validator/index.js';
-import './reference-BNqcwZWH.js';
-import './capabilities-DXA-L0iT.js';
+import { a as getInternalHelperManager, f as hasValue, h as hasDestroyable } from './api-zh_k31vb.js';
 import { getOwner } from '../@glimmer/owner/index.js';
-import { E as EMPTY_ARGS, c as EMPTY_NAMED, d as EMPTY_POSITIONAL } from './on-CersD7PL.js';
-
-/**
- * Performs a strict equality comparison.
- *
- * left === right
- */
-function eq(left, right) {
-  return left === right;
-}
+import { b as createCache, g as getValue } from './cache-BIlOoPA7.js';
+import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './debug-render-tree-BLtnOSbb.js';
 
 function getArgs(proxy) {
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
@@ -59,13 +48,4 @@ function invokeHelper(context, definition, computeArgs) {
   return cache;
 }
 
-/**
- * Performs a strict inequality comparison.
- *
- * left !== right
- */
-function neq(left, right) {
-  return left !== right;
-}
-
-export { eq as e, invokeHelper as i, neq as n };
+export { invokeHelper as i };

package/dist/{dev/packages/shared-chunks/is_proxy-B0smdQy8.js → prod/packages/shared-chunks/is_proxy-Bzg0d4m4.js}

@@ -1,4 +1,4 @@
-import { i as isObject } from './mandatory-setter-DHZe7-kW.js';
+import { i as isObject } from './spec-BXl1reqK.js';
 
 const PROXIES = new WeakSet();
 function isProxy(value) {

package/dist/prod/packages/shared-chunks/libraries-DaXpIDYN.js

@@ -0,0 +1,60 @@
+import './env-DXxsTFkM.js';
+import VERSION from '../ember/version.js';
+import './property_get-hWJ0nGhW.js';
+
+/**
+ @module ember
+*/
+/**
+  Helper class that allows you to register your library with Ember.
+
+  Singleton created at `Ember.libraries`.
+
+  @class Libraries
+  @constructor
+  @private
+*/
+class Libraries {
+  _registry;
+  _coreLibIndex;
+  constructor() {
+    this._registry = [];
+    this._coreLibIndex = 0;
+  }
+  _getLibraryByName(name) {
+    let libs = this._registry;
+    for (let lib of libs) {
+      if (lib.name === name) {
+        return lib;
+      }
+    }
+    return undefined;
+  }
+  register(name, version, isCoreLibrary) {
+    let index = this._registry.length;
+    if (!this._getLibraryByName(name)) {
+      if (isCoreLibrary) {
+        index = this._coreLibIndex++;
+      }
+      this._registry.splice(index, 0, {
+        name,
+        version
+      });
+    }
+  }
+  registerCoreLibrary(name, version) {
+    this.register(name, version, true);
+  }
+  deRegister(name) {
+    let lib = this._getLibraryByName(name);
+    let index;
+    if (lib) {
+      index = this._registry.indexOf(lib);
+      this._registry.splice(index, 1);
+    }
+  }
+}
+const LIBRARIES = new Libraries();
+LIBRARIES.registerCoreLibrary('Ember', VERSION);
+
+export { Libraries as L, LIBRARIES as a };

package/dist/prod/packages/shared-chunks/meta-B9mldqPL.js

@@ -0,0 +1,36 @@
+import { c as createUpdatableTag, D as DIRTY_TAG } from './cache-BIlOoPA7.js';
+
+///////////
+
+const TRACKED_TAGS = new WeakMap();
+function dirtyTagFor(obj, key, meta) {
+  let tags = meta === undefined ? TRACKED_TAGS.get(obj) : meta;
+
+  // No tags have been setup for this object yet, return
+  if (tags === undefined) return;
+
+  // Dirty the tag for the specific property if it exists
+  let propertyTag = tags.get(key);
+  if (propertyTag !== undefined) {
+    DIRTY_TAG(propertyTag, true);
+  }
+}
+function tagMetaFor(obj) {
+  let tags = TRACKED_TAGS.get(obj);
+  if (tags === undefined) {
+    tags = new Map();
+    TRACKED_TAGS.set(obj, tags);
+  }
+  return tags;
+}
+function tagFor(obj, key, meta) {
+  let tags = meta === undefined ? tagMetaFor(obj) : meta;
+  let tag = tags.get(key);
+  if (tag === undefined) {
+    tag = createUpdatableTag();
+    tags.set(key, tag);
+  }
+  return tag;
+}
+
+export { tagMetaFor as a, dirtyTagFor as d, tagFor as t };

package/dist/{dev/packages/shared-chunks/name-Z7dpqvzn.js → prod/packages/shared-chunks/name-Clp4Vsod.js}

@@ -1,4 +1,4 @@
-import { i as isObject } from './mandatory-setter-DHZe7-kW.js';
+import { i as isObject } from './spec-BXl1reqK.js';
 
 const NAMES = new WeakMap();
 function setName(obj, name) {

package/dist/prod/packages/shared-chunks/namespace_search-BfvzEQzN.js

@@ -0,0 +1,134 @@
+import { context } from '../@ember/-internals/environment/index.js';
+import { s as setName, g as getName } from './name-Clp4Vsod.js';
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+let searchDisabled = false;
+const flags = {
+  _set: 0,
+  _unprocessedNamespaces: false,
+  get unprocessedNamespaces() {
+    return this._unprocessedNamespaces;
+  },
+  set unprocessedNamespaces(v) {
+    this._set++;
+    this._unprocessedNamespaces = v;
+  }
+};
+let unprocessedMixins = false;
+const NAMESPACES = [];
+const NAMESPACES_BY_ID = Object.create(null);
+function addNamespace(namespace) {
+  flags.unprocessedNamespaces = true;
+  NAMESPACES.push(namespace);
+}
+function removeNamespace(namespace) {
+  let name = getName(namespace);
+  delete NAMESPACES_BY_ID[name];
+  NAMESPACES.splice(NAMESPACES.indexOf(namespace), 1);
+  if (name in context.lookup && namespace === context.lookup[name]) {
+    context.lookup[name] = undefined;
+  }
+}
+function findNamespaces() {
+  if (!flags.unprocessedNamespaces) {
+    return;
+  }
+  let lookup = context.lookup;
+  let keys = Object.keys(lookup);
+  for (let key of keys) {
+    // Only process entities that start with uppercase A-Z
+    if (!isUppercase(key.charCodeAt(0))) {
+      continue;
+    }
+    let obj = tryIsNamespace(lookup, key);
+    if (obj) {
+      setName(obj, key);
+    }
+  }
+}
+function findNamespace(name) {
+  if (!searchDisabled) {
+    processAllNamespaces();
+  }
+  return NAMESPACES_BY_ID[name];
+}
+function processNamespace(namespace) {
+  _processNamespace([namespace.toString()], namespace, new Set());
+}
+function processAllNamespaces() {
+  let unprocessedNamespaces = flags.unprocessedNamespaces;
+  if (unprocessedNamespaces) {
+    findNamespaces();
+    flags.unprocessedNamespaces = false;
+  }
+  if (unprocessedNamespaces || unprocessedMixins) {
+    let namespaces = NAMESPACES;
+    for (let namespace of namespaces) {
+      processNamespace(namespace);
+    }
+    unprocessedMixins = false;
+  }
+}
+function isSearchDisabled() {
+  return searchDisabled;
+}
+function setSearchDisabled(flag) {
+  searchDisabled = Boolean(flag);
+}
+function setUnprocessedMixins() {
+  unprocessedMixins = true;
+}
+function _processNamespace(paths, root, seen) {
+  let idx = paths.length;
+  let id = paths.join('.');
+  NAMESPACES_BY_ID[id] = root;
+  setName(root, id);
+
+  // Loop over all of the keys in the namespace, looking for classes
+  for (let key in root) {
+    if (!hasOwnProperty.call(root, key)) {
+      continue;
+    }
+    let obj = root[key];
+
+    // If we are processing the `Ember` namespace, for example, the
+    // `paths` will start with `["Ember"]`. Every iteration through
+    // the loop will update the **second** element of this list with
+    // the key, so processing `Ember.View` will make the Array
+    // `['Ember', 'View']`.
+    paths[idx] = key;
+
+    // If we have found an unprocessed class
+    if (obj && getName(obj) === void 0) {
+      // Replace the class' `toString` with the dot-separated path
+      setName(obj, paths.join('.'));
+      // Support nested namespaces
+    } else if (obj && isNamespace(obj)) {
+      // Skip aliased namespaces
+      if (seen.has(obj)) {
+        continue;
+      }
+      seen.add(obj);
+      // Process the child namespace
+      _processNamespace(paths, obj, seen);
+    }
+  }
+  paths.length = idx; // cut out last item
+}
+function isNamespace(obj) {
+  return obj != null && typeof obj === 'object' && obj.isNamespace;
+}
+function isUppercase(code) {
+  return code >= 65 && code <= 90 // A
+; // Z
+}
+function tryIsNamespace(lookup, prop) {
+  try {
+    let obj = lookup[prop];
+    return (obj !== null && typeof obj === 'object' || typeof obj === 'function') && obj.isNamespace && obj;
+  } catch (_e) {
+    // continue
+  }
+}
+
+export { NAMESPACES as N, NAMESPACES_BY_ID as a, addNamespace as b, findNamespaces as c, processNamespace as d, setSearchDisabled as e, findNamespace as f, isSearchDisabled as i, processAllNamespaces as p, removeNamespace as r, setUnprocessedMixins as s };

package/dist/prod/packages/shared-chunks/normalize-D9jDJVGg.js

@@ -0,0 +1,84 @@
+import { e as expect } from './collections-C3Y8z_9v.js';
+import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
+
+class CursorImpl {
+  constructor(element, nextSibling) {
+    this.element = element;
+    this.nextSibling = nextSibling;
+    setLocalDebugType('cursor', this);
+  }
+}
+class ConcreteBounds {
+  constructor(parentNode, first, last) {
+    this.parentNode = parentNode;
+    this.first = first;
+    this.last = last;
+  }
+  parentElement() {
+    return this.parentNode;
+  }
+  firstNode() {
+    return this.first;
+  }
+  lastNode() {
+    return this.last;
+  }
+}
+function move(bounds, reference) {
+  let parent = bounds.parentElement();
+  let first = bounds.firstNode();
+  let last = bounds.lastNode();
+  let current = first;
+  while (true) {
+    let next = current.nextSibling;
+    parent.insertBefore(current, reference);
+    if (current === last) {
+      return next;
+    }
+    current = expect(next);
+  }
+}
+function clear(bounds) {
+  let parent = bounds.parentElement();
+  let first = bounds.firstNode();
+  let last = bounds.lastNode();
+  let current = first;
+  while (true) {
+    let next = current.nextSibling;
+    parent.removeChild(current);
+    if (current === last) {
+      return next;
+    }
+    current = expect(next);
+  }
+}
+
+function normalizeStringValue(value) {
+  if (isEmpty(value)) {
+    return '';
+  }
+  return String(value);
+}
+function shouldCoerce(value) {
+  return isString(value) || isEmpty(value) || typeof value === 'boolean' || typeof value === 'number';
+}
+function isEmpty(value) {
+  return value === null || value === undefined || typeof value.toString !== 'function';
+}
+function isIndexable(value) {
+  return value !== null && typeof value === 'object';
+}
+function isSafeString(value) {
+  return isIndexable(value) && typeof value['toHTML'] === 'function';
+}
+function isNode(value) {
+  return isIndexable(value) && typeof value['nodeType'] === 'number';
+}
+function isFragment(value) {
+  return isIndexable(value) && value['nodeType'] === 11;
+}
+function isString(value) {
+  return typeof value === 'string';
+}
+
+export { ConcreteBounds as C, CursorImpl as a, isEmpty as b, clear as c, isString as d, isFragment as e, isNode as f, isSafeString as i, move as m, normalizeStringValue as n, shouldCoerce as s };