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

package/dist/dev/packages/shared-chunks/libraries-CHBwbR72.js

@@ -0,0 +1,79 @@
+import { warn, debug } from '../@ember/debug/index.js';
+import VERSION from '../ember/version.js';
+import { g as get } from './property_get-CIBS9umw.js';
+import { assert } from '../@ember/debug/lib/assert.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
+      });
+    } else {
+      (warn(`Library "${name}" is already registered with Ember.`, false, {
+        id: 'ember-metal.libraries-register'
+      }));
+    }
+  }
+  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);
+    }
+  }
+}
+{
+  Libraries.prototype.logVersions = function () {
+    let libs = this._registry;
+    let nameLengths = libs.map(item => get(item, 'name.length'));
+    (!(nameLengths instanceof Array && nameLengths.every(n => typeof n === 'number')) && assert('nameLengths is number array', nameLengths instanceof Array && nameLengths.every(n => typeof n === 'number')));
+    let maxNameLength = Math.max.apply(null, nameLengths);
+    debug('-------------------------------');
+    for (let lib of libs) {
+      let spaces = new Array(maxNameLength - lib.name.length + 1).join(' ');
+      debug([lib.name, spaces, ' : ', lib.version].join(''));
+    }
+    debug('-------------------------------');
+  };
+}
+const LIBRARIES = new Libraries();
+LIBRARIES.registerCoreLibrary('Ember', VERSION);
+
+export { LIBRARIES as L, Libraries as a };

package/dist/dev/packages/shared-chunks/mandatory-setter-BpbAMTzV.js

@@ -0,0 +1,107 @@
+import '../@ember/debug/index.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+function lookupDescriptor(obj, keyName) {
+  let current = obj;
+  do {
+    let descriptor = Object.getOwnPropertyDescriptor(current, keyName);
+    if (descriptor !== undefined) {
+      return descriptor;
+    }
+    current = Object.getPrototypeOf(current);
+  } while (current !== null);
+  return null;
+}
+
+let setupMandatorySetter;
+let teardownMandatorySetter;
+let setWithMandatorySetter;
+function isElementKey(key) {
+  return typeof key === 'number' ? isPositiveInt(key) : isStringInt(key);
+}
+function isStringInt(str) {
+  let num = parseInt(str, 10);
+  return isPositiveInt(num) && str === String(num);
+}
+function isPositiveInt(num) {
+  return num >= 0 && num % 1 === 0;
+}
+{
+  let SEEN_TAGS = new WeakSet();
+  let MANDATORY_SETTERS = new WeakMap();
+  let propertyIsEnumerable = function (obj, key) {
+    return Object.prototype.propertyIsEnumerable.call(obj, key);
+  };
+  setupMandatorySetter = function (tag, obj, keyName) {
+    if (SEEN_TAGS.has(tag)) {
+      return;
+    }
+    SEEN_TAGS.add(tag);
+    if (Array.isArray(obj) && isElementKey(keyName)) {
+      return;
+    }
+    let desc = lookupDescriptor(obj, keyName) || {};
+    if (desc.get || desc.set) {
+      // if it has a getter or setter, we can't install the mandatory setter.
+      // native setters are allowed, we have to assume that they will resolve
+      // to tracked properties.
+      return;
+    }
+    if (desc && (!desc.configurable || !desc.writable)) {
+      // if it isn't writable anyways, so we shouldn't provide the setter.
+      // if it isn't configurable, we can't overwrite it anyways.
+      return;
+    }
+    let setters = MANDATORY_SETTERS.get(obj);
+    if (setters === undefined) {
+      setters = {};
+      MANDATORY_SETTERS.set(obj, setters);
+    }
+    desc.hadOwnProperty = Object.hasOwnProperty.call(obj, keyName);
+    setters[keyName] = desc;
+    Object.defineProperty(obj, keyName, {
+      configurable: true,
+      enumerable: propertyIsEnumerable(obj, keyName),
+      get() {
+        if (desc.get) {
+          return desc.get.call(this);
+        } else {
+          return desc.value;
+        }
+      },
+      set(value) {
+        (assert(`You attempted to update ${this}.${String(keyName)} to "${String(value)}", but it is being tracked by a tracking context, such as a template, computed property, or observer. In order to make sure the context updates properly, you must invalidate the property when updating it. You can mark the property as \`@tracked\`, or use \`@ember/object#set\` to do this.`));
+      }
+    });
+  };
+  teardownMandatorySetter = function (obj, keyName) {
+    let setters = MANDATORY_SETTERS.get(obj);
+    if (setters !== undefined && setters[keyName] !== undefined) {
+      Object.defineProperty(obj, keyName, setters[keyName]);
+      delete setters[keyName];
+    }
+  };
+  setWithMandatorySetter = function (obj, keyName, value) {
+    let setters = MANDATORY_SETTERS.get(obj);
+    if (setters !== undefined && setters[keyName] !== undefined) {
+      let setter = setters[keyName];
+      if (setter.set) {
+        setter.set.call(obj, value);
+      } else {
+        setter.value = value;
+
+        // If the object didn't have own property before, it would have changed
+        // the enumerability after setting the value the first time.
+        if (!setter.hadOwnProperty) {
+          let desc = lookupDescriptor(obj, keyName);
+          desc.enumerable = true;
+          Object.defineProperty(obj, keyName, desc);
+        }
+      }
+    } else {
+      obj[keyName] = value;
+    }
+  };
+}
+
+export { setupMandatorySetter as a, lookupDescriptor as l, setWithMandatorySetter as s, teardownMandatorySetter as t };

package/dist/dev/packages/shared-chunks/meta-BmRXesrk.js

@@ -0,0 +1,46 @@
+import { n as createUpdatableTag, B as unwrap, o as debug, D as DIRTY_TAG } from './cache-B7dqAS38.js';
+
+function isObjectLike(u) {
+  return typeof u === 'object' && u !== null || typeof u === 'function';
+}
+
+///////////
+
+const TRACKED_TAGS = new WeakMap();
+function dirtyTagFor(obj, key, meta) {
+  if (!isObjectLike(obj)) {
+    throw new Error(`BUG: Can't update a tag for a primitive`);
+  }
+  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) {
+    {
+      unwrap(debug.assertTagNotConsumed)(propertyTag, obj, key);
+    }
+    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/{prod/packages/shared-chunks/name-C68GLLO3.js → dev/packages/shared-chunks/name-Clp4Vsod.js}

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

package/dist/dev/packages/shared-chunks/{namespace_search-uT8odThF.js → namespace_search-BfvzEQzN.js}

@@ -1,6 +1,5 @@
 import { context } from '../@ember/-internals/environment/index.js';
-import './mandatory-setter-DHZe7-kW.js';
-import { s as setName, g as getName } from './name-Z7dpqvzn.js';
+import { s as setName, g as getName } from './name-Clp4Vsod.js';
 
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 let searchDisabled = false;

package/dist/dev/packages/shared-chunks/normalize-CKySQVU7.js

@@ -0,0 +1,84 @@
+import { e as expect } from './collections-DPkjqeA3.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 };

package/dist/dev/packages/shared-chunks/observers-C2DurkLG.js

@@ -0,0 +1,199 @@
+import { E as ENV } from './env-g-kaAFLN.js';
+import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import { registerDestructor } from '../@glimmer/destroyable/index.js';
+import { z as valueForTag, y as validateTag, c as CURRENT_TAG } from './cache-B7dqAS38.js';
+import { a as tagMetaFor } from './meta-BmRXesrk.js';
+import { g as getChainTagsForKey } from './chain-tags-D6tuFUj_.js';
+import { a as addListener, r as removeListener, s as sendEvent } from './events-6aFVjD4k.js';
+
+const AFTER_OBSERVERS = ':change';
+function changeEvent(keyName) {
+  return keyName + AFTER_OBSERVERS;
+}
+
+const SYNC_DEFAULT = !ENV._DEFAULT_ASYNC_OBSERVERS;
+const SYNC_OBSERVERS = new Map();
+const ASYNC_OBSERVERS = new Map();
+
+/**
+@module @ember/object
+*/
+
+/**
+  @method addObserver
+  @static
+  @for @ember/object/observers
+  @param obj
+  @param {String} path
+  @param {Object|Function} target
+  @param {Function|String} [method]
+  @public
+*/
+function addObserver(obj, path, target, method, sync = SYNC_DEFAULT) {
+  let eventName = changeEvent(path);
+  addListener(obj, eventName, target, method, false, sync);
+  let meta = peekMeta(obj);
+  if (meta === null || !(meta.isPrototypeMeta(obj) || meta.isInitializing())) {
+    activateObserver(obj, eventName, sync);
+  }
+}
+
+/**
+  @method removeObserver
+  @static
+  @for @ember/object/observers
+  @param obj
+  @param {String} path
+  @param {Object|Function} target
+  @param {Function|String} [method]
+  @public
+*/
+function removeObserver(obj, path, target, method, sync = SYNC_DEFAULT) {
+  let eventName = changeEvent(path);
+  let meta = peekMeta(obj);
+  if (meta === null || !(meta.isPrototypeMeta(obj) || meta.isInitializing())) {
+    deactivateObserver(obj, eventName, sync);
+  }
+  removeListener(obj, eventName, target, method);
+}
+function getOrCreateActiveObserversFor(target, sync) {
+  let observerMap = sync === true ? SYNC_OBSERVERS : ASYNC_OBSERVERS;
+  if (!observerMap.has(target)) {
+    observerMap.set(target, new Map());
+    registerDestructor(target, () => destroyObservers(target), true);
+  }
+  return observerMap.get(target);
+}
+function activateObserver(target, eventName, sync = false) {
+  let activeObservers = getOrCreateActiveObserversFor(target, sync);
+  if (activeObservers.has(eventName)) {
+    activeObservers.get(eventName).count++;
+  } else {
+    let path = eventName.substring(0, eventName.lastIndexOf(':'));
+    let tag = getChainTagsForKey(target, path, tagMetaFor(target), peekMeta(target));
+    activeObservers.set(eventName, {
+      count: 1,
+      path,
+      tag,
+      lastRevision: valueForTag(tag),
+      suspended: false
+    });
+  }
+}
+let DEACTIVATE_SUSPENDED = false;
+let SCHEDULED_DEACTIVATE = [];
+function deactivateObserver(target, eventName, sync = false) {
+  if (DEACTIVATE_SUSPENDED === true) {
+    SCHEDULED_DEACTIVATE.push([target, eventName, sync]);
+    return;
+  }
+  let observerMap = sync === true ? SYNC_OBSERVERS : ASYNC_OBSERVERS;
+  let activeObservers = observerMap.get(target);
+  if (activeObservers !== undefined) {
+    let observer = activeObservers.get(eventName);
+    observer.count--;
+    if (observer.count === 0) {
+      activeObservers.delete(eventName);
+      if (activeObservers.size === 0) {
+        observerMap.delete(target);
+      }
+    }
+  }
+}
+function suspendedObserverDeactivation() {
+  DEACTIVATE_SUSPENDED = true;
+}
+function resumeObserverDeactivation() {
+  DEACTIVATE_SUSPENDED = false;
+  for (let [target, eventName, sync] of SCHEDULED_DEACTIVATE) {
+    deactivateObserver(target, eventName, sync);
+  }
+  SCHEDULED_DEACTIVATE = [];
+}
+
+/**
+ * Primarily used for cases where we are redefining a class, e.g. mixins/reopen
+ * being applied later. Revalidates all the observers, resetting their tags.
+ *
+ * @private
+ * @param target
+ */
+function revalidateObservers(target) {
+  if (ASYNC_OBSERVERS.has(target)) {
+    ASYNC_OBSERVERS.get(target).forEach(observer => {
+      observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+      observer.lastRevision = valueForTag(observer.tag);
+    });
+  }
+  if (SYNC_OBSERVERS.has(target)) {
+    SYNC_OBSERVERS.get(target).forEach(observer => {
+      observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+      observer.lastRevision = valueForTag(observer.tag);
+    });
+  }
+}
+let lastKnownRevision = 0;
+function flushAsyncObservers(_schedule) {
+  let currentRevision = valueForTag(CURRENT_TAG);
+  if (lastKnownRevision === currentRevision) {
+    return;
+  }
+  lastKnownRevision = currentRevision;
+  ASYNC_OBSERVERS.forEach((activeObservers, target) => {
+    let meta = peekMeta(target);
+    activeObservers.forEach((observer, eventName) => {
+      if (!validateTag(observer.tag, observer.lastRevision)) {
+        let sendObserver = () => {
+          try {
+            sendEvent(target, eventName, [target, observer.path], undefined, meta);
+          } finally {
+            observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+            observer.lastRevision = valueForTag(observer.tag);
+          }
+        };
+        if (_schedule) {
+          _schedule('actions', sendObserver);
+        } else {
+          sendObserver();
+        }
+      }
+    });
+  });
+}
+function flushSyncObservers() {
+  // When flushing synchronous observers, we know that something has changed (we
+  // only do this during a notifyPropertyChange), so there's no reason to check
+  // a global revision.
+
+  SYNC_OBSERVERS.forEach((activeObservers, target) => {
+    let meta = peekMeta(target);
+    activeObservers.forEach((observer, eventName) => {
+      if (!observer.suspended && !validateTag(observer.tag, observer.lastRevision)) {
+        try {
+          observer.suspended = true;
+          sendEvent(target, eventName, [target, observer.path], undefined, meta);
+        } finally {
+          observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+          observer.lastRevision = valueForTag(observer.tag);
+          observer.suspended = false;
+        }
+      }
+    });
+  });
+}
+function setObserverSuspended(target, property, suspended) {
+  let activeObservers = SYNC_OBSERVERS.get(target);
+  if (!activeObservers) {
+    return;
+  }
+  let observer = activeObservers.get(changeEvent(property));
+  if (observer) {
+    observer.suspended = suspended;
+  }
+}
+function destroyObservers(target) {
+  if (SYNC_OBSERVERS.size > 0) SYNC_OBSERVERS.delete(target);
+  if (ASYNC_OBSERVERS.size > 0) ASYNC_OBSERVERS.delete(target);
+}
+
+export { ASYNC_OBSERVERS as A, SYNC_OBSERVERS as S, activateObserver as a, addObserver as b, revalidateObservers as c, flushSyncObservers as d, resumeObserverDeactivation as e, flushAsyncObservers as f, setObserverSuspended as g, removeObserver as r, suspendedObserverDeactivation as s };