ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/prod/packages/@ember/utils/lib/is-equal.js

@@ -0,0 +1,60 @@
+/**
+ @module @ember/utils
+*/
+/**
+  Compares two objects, returning true if they are equal.
+
+  ```javascript
+  import { isEqual } from '@ember/utils';
+
+  isEqual('hello', 'hello');                   // true
+  isEqual(1, 2);                               // false
+  ```
+
+  `isEqual` is a more specific comparison than a triple equal comparison.
+  It will call the `isEqual` instance method on the objects being
+  compared, allowing finer control over when objects should be considered
+  equal to each other.
+
+  ```javascript
+  import { isEqual } from '@ember/utils';
+  import EmberObject from '@ember/object';
+
+  class Person extends EmberObject {
+    isEqual(other: Person) { return this.ssn == other.ssn; }
+  }
+
+  let personA = Person.create({name: 'Muhammad Ali', ssn: '123-45-6789'});
+  let personB = Person.create({name: 'Cassius Clay', ssn: '123-45-6789'});
+
+  isEqual(personA, personB); // true
+  ```
+
+  Due to the expense of array comparisons, collections will never be equal to
+  each other even if each of their items are equal to each other.
+
+  ```javascript
+  import { isEqual } from '@ember/utils';
+
+  isEqual([4, 2], [4, 2]);                     // false
+  ```
+
+  @method isEqual
+  @for @ember/utils
+  @static
+  @param {Object} a first object to compare
+  @param {Object} b second object to compare
+  @return {Boolean}
+  @public
+*/
+function isEqual(a, b) {
+  if (a && typeof a.isEqual === 'function') {
+    return a.isEqual(b);
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  return a === b;
+}
+
+export { isEqual as default };

package/dist/prod/packages/@ember/utils/lib/is_blank.js

@@ -0,0 +1,36 @@
+import isEmpty from './is_empty.js';
+
+/**
+ @module @ember/utils
+*/
+/**
+  A value is blank if it is empty or a whitespace string.
+
+  ```javascript
+  import { isBlank } from '@ember/utils';
+
+  isBlank(null);            // true
+  isBlank(undefined);       // true
+  isBlank('');              // true
+  isBlank([]);              // true
+  isBlank('\n\t');          // true
+  isBlank('  ');            // true
+  isBlank({});              // false
+  isBlank('\n\t Hello');    // false
+  isBlank('Hello world');   // false
+  isBlank([1,2,3]);         // false
+  ```
+
+  @method isBlank
+  @static
+  @for @ember/utils
+  @param {Object} obj Value to test
+  @return {Boolean}
+  @since 1.5.0
+  @public
+*/
+function isBlank(obj) {
+  return isEmpty(obj) || typeof obj === 'string' && /\S/.test(obj) === false;
+}
+
+export { isBlank as default };

package/dist/prod/packages/@ember/utils/lib/is_empty.js

@@ -0,0 +1,67 @@
+import '../../object/index.js';
+import '../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../-internals/environment/index.js';
+import '../../../@glimmer/validator/index.js';
+import '../../../shared-chunks/reference-BNqcwZWH.js';
+import '../../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { m as hasUnknownProperty, g as get } from '../../../shared-chunks/observers-R1ZklwWy.js';
+
+/**
+ @module @ember/utils
+*/
+/**
+  Verifies that a value is `null` or `undefined`, an empty string, or an empty
+  array.
+
+  Constrains the rules on `isNone` by returning true for empty strings and
+  empty arrays.
+
+  If the value is an object with a `size` property of type number, it is used
+  to check emptiness.
+
+  ```javascript
+  isEmpty(null);             // true
+  isEmpty(undefined);        // true
+  isEmpty('');               // true
+  isEmpty([]);               // true
+  isEmpty({ size: 0});       // true
+  isEmpty({});               // false
+  isEmpty('Adam Hawkins');   // false
+  isEmpty([0,1,2]);          // false
+  isEmpty('\n\t');           // false
+  isEmpty('  ');             // false
+  isEmpty({ size: 1 })       // false
+  isEmpty({ size: () => 0 }) // false
+  ```
+
+  @method isEmpty
+  @static
+  @for @ember/utils
+  @param {Object} obj Value to test
+  @return {Boolean}
+  @public
+*/
+function isEmpty(obj) {
+  if (obj === null || obj === undefined) {
+    return true;
+  }
+  if (!hasUnknownProperty(obj) && typeof obj.size === 'number') {
+    return !obj.size;
+  }
+  if (typeof obj === 'object') {
+    let size = get(obj, 'size');
+    if (typeof size === 'number') {
+      return !size;
+    }
+    let length = get(obj, 'length');
+    if (typeof length === 'number') {
+      return !length;
+    }
+  }
+  if (typeof obj.length === 'number' && typeof obj !== 'function') {
+    return !obj.length;
+  }
+  return false;
+}
+
+export { isEmpty as default };

package/dist/prod/packages/@ember/utils/lib/is_none.js

@@ -0,0 +1,28 @@
+/**
+ @module @ember/utils
+*/
+/**
+  Returns true if the passed value is null or undefined. This avoids errors
+  from JSLint complaining about use of ==, which can be technically
+  confusing.
+
+  ```javascript
+  isNone(null);          // true
+  isNone(undefined);     // true
+  isNone('');            // false
+  isNone([]);            // false
+  isNone(function() {}); // false
+  ```
+
+  @method isNone
+  @static
+  @for @ember/utils
+  @param {Object} obj Value to test
+  @return {Boolean}
+  @public
+*/
+function isNone(obj) {
+  return obj === null || obj === undefined;
+}
+
+export { isNone as default };

package/dist/prod/packages/@ember/utils/lib/is_present.js

@@ -0,0 +1,39 @@
+import isBlank from './is_blank.js';
+
+/**
+ @module @ember/utils
+*/
+/**
+  A value is present if it not `isBlank`.
+
+  ```javascript
+  isPresent(null);            // false
+  isPresent(undefined);       // false
+  isPresent('');              // false
+  isPresent('  ');            // false
+  isPresent('\n\t');          // false
+  isPresent([]);              // false
+  isPresent({ length: 0 });   // false
+  isPresent(false);           // true
+  isPresent(true);            // true
+  isPresent('string');        // true
+  isPresent(0);               // true
+  isPresent(function() {});   // true
+  isPresent({});              // true
+  isPresent('\n\t Hello');    // true
+  isPresent([1, 2, 3]);       // true
+  ```
+
+  @method isPresent
+  @static
+  @for @ember/utils
+  @param {Object} obj Value to test
+  @return {Boolean}
+  @since 1.8.0
+  @public
+*/
+function isPresent(obj) {
+  return !isBlank(obj);
+}
+
+export { isPresent as default };

package/dist/prod/packages/@ember/utils/lib/type-of.js

@@ -0,0 +1,110 @@
+import CoreObject from '../../object/core.js';
+
+// ........................................
+// TYPING & ARRAY MESSAGING
+//
+const TYPE_MAP = {
+  '[object Boolean]': 'boolean',
+  '[object Number]': 'number',
+  '[object String]': 'string',
+  '[object Function]': 'function',
+  '[object AsyncFunction]': 'function',
+  '[object Array]': 'array',
+  '[object Date]': 'date',
+  '[object RegExp]': 'regexp',
+  '[object Object]': 'object',
+  '[object FileList]': 'filelist'
+};
+const {
+  toString
+} = Object.prototype;
+
+/**
+ @module @ember/utils
+*/
+/**
+  Returns a consistent type for the passed object.
+
+  Use this instead of the built-in `typeof` to get the type of an item.
+  It will return the same result across all browsers and includes a bit
+  more detail. Here is what will be returned:
+
+      | Return Value  | Meaning                                              |
+      |---------------|------------------------------------------------------|
+      | 'string'      | String primitive or String object.                   |
+      | 'number'      | Number primitive or Number object.                   |
+      | 'boolean'     | Boolean primitive or Boolean object.                 |
+      | 'null'        | Null value                                           |
+      | 'undefined'   | Undefined value                                      |
+      | 'function'    | A function                                           |
+      | 'array'       | An instance of Array                                 |
+      | 'regexp'      | An instance of RegExp                                |
+      | 'date'        | An instance of Date                                  |
+      | 'filelist'    | An instance of FileList                              |
+      | 'class'       | An Ember class (created using EmberObject.extend())  |
+      | 'instance'    | An Ember object instance                             |
+      | 'error'       | An instance of the Error object                      |
+      | 'object'      | A JavaScript object not inheriting from EmberObject  |
+
+  Examples:
+
+  ```javascript
+  import { A } from '@ember/array';
+  import { typeOf } from '@ember/utils';
+  import EmberObject from '@ember/object';
+
+  typeOf();                       // 'undefined'
+  typeOf(null);                   // 'null'
+  typeOf(undefined);              // 'undefined'
+  typeOf('michael');              // 'string'
+  typeOf(new String('michael'));  // 'string'
+  typeOf(101);                    // 'number'
+  typeOf(new Number(101));        // 'number'
+  typeOf(true);                   // 'boolean'
+  typeOf(new Boolean(true));      // 'boolean'
+  typeOf(A);                      // 'function'
+  typeOf(A());                    // 'array'
+  typeOf([1, 2, 90]);             // 'array'
+  typeOf(/abc/);                  // 'regexp'
+  typeOf(new Date());             // 'date'
+  typeOf(event.target.files);     // 'filelist'
+  typeOf(EmberObject.extend());   // 'class'
+  typeOf(EmberObject.create());   // 'instance'
+  typeOf(new Error('teamocil'));  // 'error'
+
+  // 'normal' JavaScript object
+  typeOf({ a: 'b' });             // 'object'
+  ```
+
+  @method typeOf
+  @for @ember/utils
+  @param item the item to check
+  @return {String} the type
+  @public
+  @static
+*/
+function typeOf(item) {
+  if (item === null) {
+    return 'null';
+  }
+  if (item === undefined) {
+    return 'undefined';
+  }
+  let ret = TYPE_MAP[toString.call(item)] || 'object';
+  if (ret === 'function') {
+    if (CoreObject.detect(item)) {
+      ret = 'class';
+    }
+  } else if (ret === 'object') {
+    if (item instanceof Error) {
+      ret = 'error';
+    } else if (item instanceof CoreObject) {
+      ret = 'instance';
+    } else if (item instanceof Date) {
+      ret = 'date';
+    }
+  }
+  return ret;
+}
+
+export { typeOf as default };

package/dist/prod/packages/@ember/version/index.js

@@ -0,0 +1 @@
+export { default as VERSION } from '../../ember/version.js';

package/dist/prod/packages/@glimmer/destroyable/index.js

@@ -0,0 +1,128 @@
+import { scheduleDestroyed, scheduleDestroy } from '../global-context/index.js';
+
+const LIVE_STATE = 0;
+const DESTROYING_STATE = 1;
+const DESTROYED_STATE = 2;
+let DESTROYABLE_META = new WeakMap();
+const branded = Symbol('BrandedArray');
+function isBrandedArray(collection) {
+  return Array.isArray(collection) && branded in collection;
+}
+function push(collection, newItem) {
+  if (collection === null) {
+    return newItem;
+  } else if (isBrandedArray(collection)) {
+    collection.push(newItem);
+    return collection;
+  } else {
+    const b = [collection, newItem];
+    b[branded] = true;
+    return b;
+  }
+}
+function iterate(collection, fn) {
+  if (isBrandedArray(collection)) {
+    collection.forEach(fn);
+  } else if (collection !== null) {
+    fn(collection);
+  }
+}
+function remove(collection, item, message) {
+  if (isBrandedArray(collection) && collection.length > 1) {
+    let index = collection.indexOf(item);
+    collection.splice(index, 1);
+    return collection;
+  } else {
+    return null;
+  }
+}
+function getDestroyableMeta(destroyable) {
+  let meta = DESTROYABLE_META.get(destroyable);
+  if (meta === undefined) {
+    meta = {
+      parents: null,
+      children: null,
+      eagerDestructors: null,
+      destructors: null,
+      state: LIVE_STATE
+    };
+    DESTROYABLE_META.set(destroyable, meta);
+  }
+  return meta;
+}
+function associateDestroyableChild(parent, child) {
+  let parentMeta = getDestroyableMeta(parent);
+  let childMeta = getDestroyableMeta(child);
+  parentMeta.children = push(parentMeta.children, child);
+  childMeta.parents = push(childMeta.parents, parent);
+  return child;
+}
+function registerDestructor(destroyable, destructor, eager = false) {
+  let meta = getDestroyableMeta(destroyable);
+  let destructorsKey = eager ? 'eagerDestructors' : 'destructors';
+  meta[destructorsKey] = push(meta[destructorsKey], destructor);
+  return destructor;
+}
+function unregisterDestructor(destroyable, destructor, eager = false) {
+  let meta = getDestroyableMeta(destroyable);
+  let destructorsKey = eager ? 'eagerDestructors' : 'destructors';
+  meta[destructorsKey] = remove(meta[destructorsKey], destructor);
+}
+
+////////////
+
+function destroy(destroyable) {
+  let meta = getDestroyableMeta(destroyable);
+  if (meta.state >= DESTROYING_STATE) return;
+  let {
+    parents,
+    children,
+    eagerDestructors,
+    destructors
+  } = meta;
+  meta.state = DESTROYING_STATE;
+  iterate(children, destroy);
+  iterate(eagerDestructors, destructor => {
+    destructor(destroyable);
+  });
+  iterate(destructors, destructor => {
+    scheduleDestroy(destroyable, destructor);
+  });
+  scheduleDestroyed(() => {
+    iterate(parents, parent => {
+      removeChildFromParent(destroyable, parent);
+    });
+    meta.state = DESTROYED_STATE;
+  });
+}
+function removeChildFromParent(child, parent) {
+  let parentMeta = getDestroyableMeta(parent);
+  if (parentMeta.state !== DESTROYED_STATE) {
+    parentMeta.children = remove(parentMeta.children, child);
+  }
+}
+function destroyChildren(destroyable) {
+  let {
+    children
+  } = getDestroyableMeta(destroyable);
+  iterate(children, destroy);
+}
+function _hasDestroyableChildren(destroyable) {
+  let meta = DESTROYABLE_META.get(destroyable);
+  return meta === undefined ? false : meta.children !== null;
+}
+function isDestroying(destroyable) {
+  let meta = DESTROYABLE_META.get(destroyable);
+  return meta === undefined ? false : meta.state >= DESTROYING_STATE;
+}
+function isDestroyed(destroyable) {
+  let meta = DESTROYABLE_META.get(destroyable);
+  return meta === undefined ? false : meta.state >= DESTROYED_STATE;
+}
+
+////////////
+
+let enableDestroyableTracking;
+let assertDestroyablesDestroyed;
+
+export { _hasDestroyableChildren, assertDestroyablesDestroyed, associateDestroyableChild, destroy, destroyChildren, enableDestroyableTracking, isDestroyed, isDestroying, registerDestructor, unregisterDestructor };

package/dist/prod/packages/@glimmer/encoder/index.js

@@ -0,0 +1,28 @@
+import { b as TYPE_SIZE, A as ARG_SHIFT } from '../../shared-chunks/flags-B9qxc-pB.js';
+
+class InstructionEncoderImpl {
+  constructor(buffer) {
+    this.buffer = buffer;
+  }
+  size = 0;
+  encode(type, machine, ...args) {
+    if (type > TYPE_SIZE) {
+      throw new Error(`Opcode type over 8-bits. Got ${type}.`);
+    }
+    let first = type | machine | arguments.length - 2 << ARG_SHIFT;
+    this.buffer.push(first);
+    for (const op of args) {
+      this.buffer.push(op);
+    }
+    this.size = this.buffer.length;
+  }
+  patch(position, target) {
+    if (this.buffer[position + 1] === -1) {
+      this.buffer[position + 1] = target;
+    } else {
+      throw new Error('Trying to patch operand in populated slot instead of a reserved slot.');
+    }
+  }
+}
+
+export { InstructionEncoderImpl };

package/dist/prod/packages/@glimmer/env/index.js

@@ -0,0 +1,4 @@
+const DEBUG = false;
+const CI = false;
+
+export { CI, DEBUG };

package/dist/prod/packages/@glimmer/global-context/index.js

@@ -0,0 +1,138 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * This package contains global context functions for Glimmer. These functions
+ * are set by the embedding environment and must be set before initial render.
+ *
+ * These functions should meet the following criteria:
+ *
+ * - Must be provided by the embedder, due to having framework specific
+ *   behaviors (e.g. interop with classic Ember behaviors that should not be
+ *   upstreamed) or to being out of scope for the VM (e.g. scheduling a
+ *   revalidation)
+ * - Never differ between render roots
+ * - Never change over time
+ *
+ */
+
+//////////
+
+/**
+ * Interfaces
+ *
+ * TODO: Move these into @glimmer/interfaces, move @glimmer/interfaces to
+ * @glimmer/internal-interfaces.
+ */
+
+//////////
+
+/**
+ * Schedules a VM revalidation.
+ *
+ * Note: this has a default value so that tags can warm themselves when first loaded.
+ */
+let scheduleRevalidate = () => {};
+
+/**
+ * Schedules a destructor to run
+ *
+ * @param destroyable The destroyable being destroyed
+ * @param destructor The destructor being scheduled
+ */
+let scheduleDestroy;
+
+/**
+ * Finalizes destruction
+ *
+ * @param finalizer finalizer function
+ */
+let scheduleDestroyed;
+
+/**
+ * Hook to provide iterators for `{{each}}` loops
+ *
+ * @param value The value to create an iterator for
+ */
+let toIterator;
+
+/**
+ * Hook to specify truthiness within Glimmer templates
+ *
+ * @param value The value to convert to a boolean
+ */
+let toBool;
+
+/**
+ * Hook for specifying how Glimmer should access properties in cases where it
+ * needs to. For instance, accessing an object's values in templates.
+ *
+ * @param obj The object provided to get a value from
+ * @param path The path to get the value from
+ */
+let getProp;
+
+/**
+ * Hook for specifying how Glimmer should update props in cases where it needs
+ * to. For instance, when updating a template reference (e.g. 2-way-binding)
+ *
+ * @param obj The object provided to get a value from
+ * @param prop The prop to set the value at
+ * @param value The value to set the value to
+ */
+let setProp;
+
+/**
+ * Hook for specifying how Glimmer should access paths in cases where it needs
+ * to. For instance, the `key` value of `{{each}}` loops.
+ *
+ * @param obj The object provided to get a value from
+ * @param path The path to get the value from
+ */
+let getPath;
+
+/**
+ * Hook for specifying how Glimmer should update paths in cases where it needs
+ * to. For instance, when updating a template reference (e.g. 2-way-binding)
+ *
+ * @param obj The object provided to get a value from
+ * @param path The path to get the value from
+ */
+let setPath;
+
+/**
+ * Hook to warn if a style binding string or value was not marked as trusted
+ * (e.g. HTMLSafe)
+ */
+let warnIfStyleNotTrusted;
+
+/**
+ * Hook to customize assertion messages in the VM. Usages can be stripped out
+ * by using the @glimmer/vm-babel-plugins package.
+ */
+let assert;
+function debugAssert(test, msg, options) {
+}
+
+/**
+ * Hook to customize deprecation messages in the VM. Usages can be stripped out
+ * by using the @glimmer/vm-babel-plugins package.
+ */
+let deprecate;
+function setGlobalContext(context) {
+  scheduleRevalidate = context.scheduleRevalidate;
+  scheduleDestroy = context.scheduleDestroy;
+  scheduleDestroyed = context.scheduleDestroyed;
+  toIterator = context.toIterator;
+  toBool = context.toBool;
+  getProp = context.getProp;
+  setProp = context.setProp;
+  getPath = context.getPath;
+  setPath = context.setPath;
+  warnIfStyleNotTrusted = context.warnIfStyleNotTrusted;
+  assert = context.assert;
+  deprecate = context.deprecate;
+}
+let assertGlobalContextWasSet;
+let testOverrideGlobalContext;
+
+export { assert, assertGlobalContextWasSet, debugAssert, setGlobalContext as default, deprecate, getPath, getProp, scheduleDestroy, scheduleDestroyed, scheduleRevalidate, setPath, setProp, testOverrideGlobalContext, toBool, toIterator, warnIfStyleNotTrusted };