ember-source 6.12.0 → 7.0.0-alpha.1

package/dist/prod/packages/shared-chunks/serialize-builder-CVQ3q8rJ.js

@@ -0,0 +1,124 @@
+import './fragment-EpVz5Xuc.js';
+import '../@glimmer/validator/index.js';
+import './reference-BNqcwZWH.js';
+import { C as ConcreteBounds } from './on-CrTl7JQU.js';
+import './constants-b-2IVErl.js';
+import './capabilities-DGmQ_mz4.js';
+import { N as NewTreeBuilder } from './element-builder-CiLTrXD6.js';
+
+/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+
+const TEXT_NODE = 3;
+const NEEDS_EXTRA_CLOSE = new WeakMap();
+function currentNode(cursor) {
+  let {
+    element,
+    nextSibling
+  } = cursor;
+  if (nextSibling === null) {
+    return element.lastChild;
+  } else {
+    return nextSibling.previousSibling;
+  }
+}
+class SerializeBuilder extends NewTreeBuilder {
+  serializeBlockDepth = 0;
+  __openBlock() {
+    let {
+      tagName
+    } = this.element;
+    if (tagName !== 'TITLE' && tagName !== 'SCRIPT' && tagName !== 'STYLE') {
+      let depth = this.serializeBlockDepth++;
+      this.__appendComment(`%+b:${depth}%`);
+    }
+    super.__openBlock();
+  }
+  __closeBlock() {
+    let {
+      tagName
+    } = this.element;
+    super.__closeBlock();
+    if (tagName !== 'TITLE' && tagName !== 'SCRIPT' && tagName !== 'STYLE') {
+      let depth = --this.serializeBlockDepth;
+      this.__appendComment(`%-b:${depth}%`);
+    }
+  }
+  __appendHTML(html) {
+    let {
+      tagName
+    } = this.element;
+    if (tagName === 'TITLE' || tagName === 'SCRIPT' || tagName === 'STYLE') {
+      return super.__appendHTML(html);
+    }
+
+    // Do we need to run the html tokenizer here?
+    let first = this.__appendComment('%glmr%');
+    if (tagName === 'TABLE') {
+      let openIndex = html.indexOf('<');
+      if (openIndex > -1) {
+        let tr = html.slice(openIndex + 1, openIndex + 3);
+        if (tr === 'tr') {
+          html = `<tbody>${html}</tbody>`;
+        }
+      }
+    }
+    if (html === '') {
+      this.__appendComment('% %');
+    } else {
+      super.__appendHTML(html);
+    }
+    let last = this.__appendComment('%glmr%');
+    return new ConcreteBounds(this.element, first, last);
+  }
+  __appendText(string) {
+    let {
+      tagName
+    } = this.element;
+    let current = currentNode(this);
+    if (tagName === 'TITLE' || tagName === 'SCRIPT' || tagName === 'STYLE') {
+      return super.__appendText(string);
+    } else if (string === '') {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return this.__appendComment('% %');
+    } else if (current && current.nodeType === TEXT_NODE) {
+      this.__appendComment('%|%');
+    }
+    return super.__appendText(string);
+  }
+  closeElement() {
+    if (NEEDS_EXTRA_CLOSE.has(this.element)) {
+      NEEDS_EXTRA_CLOSE.delete(this.element);
+      super.closeElement();
+    }
+    return super.closeElement();
+  }
+  openElement(tag) {
+    if (tag === 'tr') {
+      if (this.element.tagName !== 'TBODY' && this.element.tagName !== 'THEAD' && this.element.tagName !== 'TFOOT') {
+        this.openElement('tbody');
+        // This prevents the closeBlock comment from being re-parented
+        // under the auto inserted tbody. Rehydration builder needs to
+        // account for the insertion since it is injected here and not
+        // really in the template.
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+        NEEDS_EXTRA_CLOSE.set(this.constructing, true);
+        this.flushElement(null);
+      }
+    }
+    return super.openElement(tag);
+  }
+  pushRemoteElement(element, cursorId, insertBefore = null) {
+    let {
+      dom
+    } = this;
+    let script = dom.createElement('script');
+    script.setAttribute('glmr', cursorId);
+    dom.insertBefore(element, script, insertBefore);
+    return super.pushRemoteElement(element, cursorId, insertBefore);
+  }
+}
+function serializeBuilder(env, cursor) {
+  return SerializeBuilder.forInitialRender(env, cursor);
+}
+
+export { serializeBuilder as s };

package/dist/prod/packages/shared-chunks/set_properties-CjsDTRey.js

@@ -0,0 +1,101 @@
+import { g as get } from './observers-R1ZklwWy.js';
+import { o as changeProperties } from './namespace_search-Aog9nySA.js';
+import { s as set } from './property_set-O080KTKZ.js';
+
+/**
+ @module @ember/object
+*/
+
+/**
+  To get multiple properties at once, call `getProperties`
+  with an object followed by a list of strings or an array:
+
+  ```javascript
+  import { getProperties } from '@ember/object';
+
+  getProperties(record, 'firstName', 'lastName', 'zipCode');
+  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+  ```
+
+  is equivalent to:
+
+  ```javascript
+  import { getProperties } from '@ember/object';
+
+  getProperties(record, ['firstName', 'lastName', 'zipCode']);
+  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+  ```
+
+  @method getProperties
+  @static
+  @for @ember/object
+  @param {Object} obj
+  @param {String...|Array} list of keys to get
+  @return {Object}
+  @public
+*/
+
+function getProperties(obj, keys) {
+  let ret = {};
+  let propertyNames;
+  let i = 1;
+  if (arguments.length === 2 && Array.isArray(keys)) {
+    i = 0;
+    propertyNames = arguments[1];
+  } else {
+    propertyNames = Array.from(arguments);
+  }
+  for (; i < propertyNames.length; i++) {
+    // SAFETY: we are just walking the list of property names, so we know the
+    // index access never produces `undefined`.
+    let name = propertyNames[i];
+    ret[name] = get(obj, name);
+  }
+  return ret;
+}
+
+/**
+ @module @ember/object
+*/
+/**
+  Set a list of properties on an object. These properties are set inside
+  a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+  observers will be buffered.
+
+  ```javascript
+  import EmberObject from '@ember/object';
+  let anObject = EmberObject.create();
+
+  anObject.setProperties({
+    firstName: 'Stanley',
+    lastName: 'Stuart',
+    age: 21
+  });
+  ```
+
+  @method setProperties
+  @static
+  @for @ember/object
+  @param obj
+  @param {Object} properties
+  @return properties
+  @public
+*/
+
+function setProperties(obj, properties) {
+  if (properties === null || typeof properties !== 'object') {
+    return properties;
+  }
+  changeProperties(() => {
+    let props = Object.keys(properties);
+    for (let propertyName of props) {
+      // SAFETY: casting `properties` this way is safe because any object in JS
+      // can be indexed this way, and the result will be `unknown`, making it
+      // safe for callers.
+      set(obj, propertyName, properties[propertyName]);
+    }
+  });
+  return properties;
+}
+
+export { getProperties as g, setProperties as s };

package/dist/prod/packages/shared-chunks/setup-registry-CMNYh2jY.js

@@ -0,0 +1,53 @@
+import { privatize } from '../@ember/-internals/container/index.js';
+import { getOwner } from '../@ember/-internals/owner/index.js';
+import './super-Cm_a_cLQ.js';
+import '../@ember/-internals/environment/index.js';
+import { O as OutletView, a as OutletTemplate, I as Input, L as LinkTo, T as Textarea, R as RootTemplate, b as Renderer } from './index-DZLHQAlb.js';
+import './fragment-EpVz5Xuc.js';
+import '../@glimmer/validator/index.js';
+import './reference-BNqcwZWH.js';
+import './on-CrTl7JQU.js';
+import './constants-b-2IVErl.js';
+import './capabilities-DGmQ_mz4.js';
+import { c as clientBuilder } from './element-builder-CiLTrXD6.js';
+import { r as rehydrationBuilder } from './rehydrate-builder-CSn1aIO1.js';
+import { s as serializeBuilder } from './serialize-builder-CVQ3q8rJ.js';
+
+function setupApplicationRegistry(registry) {
+  // because we are using injections we can't use instantiate false
+  // we need to use bind() to copy the function so factory for
+  // association won't leak
+  registry.register('service:-dom-builder', {
+    // Additionally, we *must* constrain this to require `props` on create, else
+    // we *know* it cannot have an owner.
+    create(props) {
+      let owner = getOwner(props);
+      let env = owner.lookup('-environment:main');
+      switch (env._renderMode) {
+        case 'serialize':
+          return serializeBuilder.bind(null);
+        case 'rehydrate':
+          return rehydrationBuilder.bind(null);
+        default:
+          return clientBuilder.bind(null);
+      }
+    }
+  });
+  registry.register(privatize`template:-root`, RootTemplate);
+  registry.register('renderer:-dom', Renderer);
+}
+function setupEngineRegistry(registry) {
+  registry.optionsForType('template', {
+    instantiate: false
+  });
+  registry.register('view:-outlet', OutletView);
+  registry.register('template:-outlet', OutletTemplate);
+  registry.optionsForType('helper', {
+    instantiate: false
+  });
+  registry.register('component:input', Input);
+  registry.register('component:link-to', LinkTo);
+  registry.register('component:textarea', Textarea);
+}
+
+export { setupEngineRegistry as a, setupApplicationRegistry as s };

package/dist/prod/packages/shared-chunks/simple-cast-DCvJLSin.js

@@ -0,0 +1,33 @@
+function castToSimple(node) {
+  if (isDocument(node)) {
+    return node;
+  } else if (isSimpleElement(node)) {
+    return node;
+  } else {
+    return node;
+  }
+}
+
+// If passed a document, verify we're in the browser and return it as a Document
+
+// If we don't know what this is, but the check requires it to be an element,
+// the cast will mandate that it's a browser element
+
+// Finally, if it's a more generic check, the cast will mandate that it's a
+// browser node and return a BrowserNodeUtils corresponding to the check
+
+function castToBrowser(node, sugaryCheck) {
+  {
+    return node;
+  }
+}
+const ELEMENT_NODE = 1;
+const DOCUMENT_NODE = 9;
+function isDocument(node) {
+  return node.nodeType === DOCUMENT_NODE;
+}
+function isSimpleElement(node) {
+  return node?.nodeType === ELEMENT_NODE;
+}
+
+export { castToBrowser as a, castToSimple as c };

package/dist/prod/packages/shared-chunks/super-Cm_a_cLQ.js

@@ -0,0 +1,275 @@
+/**
+  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;
+}
+
+/**
+  Returns whether Type(value) is Object.
+
+  Useful for checking whether a value is a valid WeakMap key.
+
+  Refs: https://tc39.github.io/ecma262/#sec-typeof-operator-runtime-semantics-evaluation
+        https://tc39.github.io/ecma262/#sec-weakmap.prototype.set
+
+  @private
+  @function isObject
+*/
+function isObject(value) {
+  return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+
+/**
+ @module @ember/object
+*/
+
+/**
+ @private
+ @return {Number} the uuid
+ */
+let _uuid = 0;
+
+/**
+ Generates a universally unique identifier. This method
+ is used internally by Ember for assisting with
+ the generation of GUID's and other unique identifiers.
+
+ @public
+ @return {Number} [description]
+ */
+function uuid() {
+  return ++_uuid;
+}
+
+/**
+ Prefix used for guids through out Ember.
+ @private
+ @property GUID_PREFIX
+ @for Ember
+ @type String
+ @final
+ */
+const GUID_PREFIX = 'ember';
+
+// Used for guid generation...
+const OBJECT_GUIDS = new WeakMap();
+const NON_OBJECT_GUIDS = new Map();
+/**
+  A unique key used to assign guids and other private metadata to objects.
+  If you inspect an object in your browser debugger you will often see these.
+  They can be safely ignored.
+
+  On browsers that support it, these properties are added with enumeration
+  disabled so they won't show up when you iterate over your properties.
+
+  @private
+  @property GUID_KEY
+  @for Ember
+  @type String
+  @final
+*/
+const GUID_KEY = intern(`__ember${Date.now()}`);
+
+/**
+  Generates a new guid, optionally saving the guid to the object that you
+  pass in. You will rarely need to use this method. Instead you should
+  call `guidFor(obj)`, which return an existing guid if available.
+
+  @private
+  @method generateGuid
+  @static
+  @for @ember/object/internals
+  @param {Object} [obj] Object the guid will be used for. If passed in, the guid will
+    be saved on the object and reused whenever you pass the same object
+    again.
+
+    If no object is passed, just generate a new guid.
+  @param {String} [prefix] Prefix to place in front of the guid. Useful when you want to
+    separate the guid into separate namespaces.
+  @return {String} the guid
+*/
+// eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
+function generateGuid(obj, prefix = GUID_PREFIX) {
+  let guid = prefix + uuid().toString();
+  if (isObject(obj)) {
+    OBJECT_GUIDS.set(obj, guid);
+  }
+  return guid;
+}
+
+/**
+  Returns a unique id for the object. If the object does not yet have a guid,
+  one will be assigned to it. You can call this on any object,
+  `EmberObject`-based or not.
+
+  You can also use this method on DOM Element objects.
+
+  @public
+  @static
+  @method guidFor
+  @for @ember/object/internals
+  @param {Object} obj any object, string, number, Element, or primitive
+  @return {String} the unique guid for this instance.
+*/
+function guidFor(value) {
+  let guid;
+  if (isObject(value)) {
+    guid = OBJECT_GUIDS.get(value);
+    if (guid === undefined) {
+      guid = `${GUID_PREFIX}${uuid()}`;
+      OBJECT_GUIDS.set(value, guid);
+    }
+  } else {
+    guid = NON_OBJECT_GUIDS.get(value);
+    if (guid === undefined) {
+      let type = typeof value;
+      if (type === 'string') {
+        guid = `st${uuid()}`;
+      } else if (type === 'number') {
+        guid = `nu${uuid()}`;
+      } else if (type === 'symbol') {
+        guid = `sy${uuid()}`;
+      } else {
+        guid = `(${value})`;
+      }
+      NON_OBJECT_GUIDS.set(value, guid);
+    }
+  }
+  return guid;
+}
+
+const HAS_SUPER_PATTERN = /\.(_super|call\(this|apply\(this)/;
+const fnToString = Function.prototype.toString;
+const checkHasSuper = (() => {
+  let sourceAvailable = fnToString.call(function () {
+    return this;
+  }).indexOf('return this') > -1;
+  if (sourceAvailable) {
+    return function checkHasSuper(func) {
+      return HAS_SUPER_PATTERN.test(fnToString.call(func));
+    };
+  }
+  return function checkHasSuper() {
+    return true;
+  };
+})();
+const HAS_SUPER_MAP = new WeakMap();
+const ROOT = Object.freeze(function () {});
+HAS_SUPER_MAP.set(ROOT, false);
+function hasSuper(func) {
+  let hasSuper = HAS_SUPER_MAP.get(func);
+  if (hasSuper === undefined) {
+    hasSuper = checkHasSuper(func);
+    HAS_SUPER_MAP.set(func, hasSuper);
+  }
+  return hasSuper;
+}
+class ObserverListenerMeta {
+  listeners = undefined;
+  observers = undefined;
+}
+const OBSERVERS_LISTENERS_MAP = new WeakMap();
+function createObserverListenerMetaFor(fn) {
+  let meta = OBSERVERS_LISTENERS_MAP.get(fn);
+  if (meta === undefined) {
+    meta = new ObserverListenerMeta();
+    OBSERVERS_LISTENERS_MAP.set(fn, meta);
+  }
+  return meta;
+}
+function observerListenerMetaFor(fn) {
+  return OBSERVERS_LISTENERS_MAP.get(fn);
+}
+function setObservers(func, observers) {
+  let meta = createObserverListenerMetaFor(func);
+  meta.observers = observers;
+}
+function setListeners(func, listeners) {
+  let meta = createObserverListenerMetaFor(func);
+  meta.listeners = listeners;
+}
+const IS_WRAPPED_FUNCTION_SET = new WeakSet();
+
+/**
+  Wraps the passed function so that `this._super` will point to the superFunc
+  when the function is invoked. This is the primitive we use to implement
+  calls to super.
+
+  @private
+  @method wrap
+  @for Ember
+  @param {Function} func The function to call
+  @param {Function} superFunc The super function.
+  @return {Function} wrapped function.
+*/
+function wrap(func, superFunc) {
+  if (!hasSuper(func)) {
+    return func;
+  }
+  // ensure an unwrapped super that calls _super is wrapped with a terminal _super
+  if (!IS_WRAPPED_FUNCTION_SET.has(superFunc) && hasSuper(superFunc)) {
+    return _wrap(func, _wrap(superFunc, ROOT));
+  }
+  return _wrap(func, superFunc);
+}
+function _wrap(func, superFunc) {
+  function superWrapper() {
+    let orig = this._super;
+    this._super = superFunc;
+    let ret = func.apply(this, arguments);
+    this._super = orig;
+    return ret;
+  }
+  IS_WRAPPED_FUNCTION_SET.add(superWrapper);
+  let meta = OBSERVERS_LISTENERS_MAP.get(func);
+  if (meta !== undefined) {
+    OBSERVERS_LISTENERS_MAP.set(superWrapper, meta);
+  }
+  return superWrapper;
+}
+
+export { GUID_KEY as G, ROOT as R, generateGuid as a, intern as b, checkHasSuper as c, setListeners as d, guidFor as g, isObject as i, observerListenerMetaFor as o, setObservers as s, uuid as u, wrap as w };

package/dist/prod/packages/shared-chunks/template-Dc_cBOoX.js

@@ -0,0 +1,19 @@
+const TEMPLATES = new WeakMap();
+const getPrototypeOf = Reflect.getPrototypeOf;
+function setComponentTemplate(factory, obj) {
+  TEMPLATES.set(obj, factory);
+  return obj;
+}
+function getComponentTemplate(obj) {
+  let pointer = obj;
+  while (pointer !== null) {
+    let template = TEMPLATES.get(pointer);
+    if (template !== undefined) {
+      return template;
+    }
+    pointer = getPrototypeOf(pointer);
+  }
+  return undefined;
+}
+
+export { getComponentTemplate as g, setComponentTemplate as s };