ember-source 7.1.0-alpha.4 → 7.1.0-beta.1

package/dist/prod/packages/shared-chunks/{decorator-BdDDBUd2.js → decorator-9ikVwsjY.js}

@@ -1,5 +1,4 @@
 import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
-import '../@ember/-internals/environment/index.js';
 
 // Same as built-in MethodDecorator but with more arguments
 

package/dist/prod/packages/shared-chunks/element-DUOVW5Ho.js

@@ -0,0 +1,100 @@
+import { a as createComputeRef, v as valueForRef, N as NULL_REFERENCE } from './reference-BshxG6wn.js';
+import { s as setInternalComponentManager } from './api-zh_k31vb.js';
+import { i as internalHelper } from './internal-helper-DIbr1RgC.js';
+
+/**
+  @module @ember/helper
+*/
+
+
+// ============ Element Component (for string tag names) ============
+// Renders content wrapped in the specified HTML element, or just renders
+// content without a wrapper for empty string.
+
+const ELEMENT_CAPABILITIES = {
+  createInstance: true,
+  wrapped: true
+};
+class ElementComponentManager {
+  getCapabilities() {
+    return ELEMENT_CAPABILITIES;
+  }
+  getDebugName(state) {
+    return `(element "${state.tagName}")`;
+  }
+  getSelf() {
+    return NULL_REFERENCE;
+  }
+  getDestroyable() {
+    return null;
+  }
+  didCreateElement() {}
+  create(_owner, state) {
+    // For empty string, return null so getTagName returns null (no wrapper element)
+    return state.tagName || null;
+  }
+  getTagName(state) {
+    return state;
+  }
+  didRenderLayout() {}
+  didUpdateLayout() {}
+  didCreate() {}
+  didUpdate() {}
+}
+const ELEMENT_COMPONENT_MANAGER = new ElementComponentManager();
+class ElementComponentDefinition {
+  constructor(tagName) {
+    this.tagName = tagName;
+  }
+  toString() {
+    return `(element "${this.tagName}")`;
+  }
+}
+setInternalComponentManager(ELEMENT_COMPONENT_MANAGER, ElementComponentDefinition.prototype);
+
+// Cache component definitions per tag name to avoid creating duplicate definitions
+const ELEMENT_DEFINITIONS = new Map();
+function getElementDefinition(tagName) {
+  let definition = ELEMENT_DEFINITIONS.get(tagName);
+  if (definition === undefined) {
+    definition = new ElementComponentDefinition(tagName);
+    ELEMENT_DEFINITIONS.set(tagName, definition);
+  }
+  return definition;
+}
+
+// ============ Element Helper ============
+
+/**
+  The `element` helper lets you dynamically set the tag name of an element.
+
+  ```handlebars
+  {{#let (element @tagName) as |Tag|}}
+    <Tag class="my-element">Hello</Tag>
+  {{/let}}
+  ```
+
+  When `@tagName` is `"h1"`, this renders `<h1 class="my-element">Hello</h1>`.
+
+  When `@tagName` is an empty string `""`, the block content is rendered without
+  a wrapping element.
+
+  Passing `null`, `undefined`, or non-string values will throw an assertion error.
+
+  Changing the tag name will tear down and recreate the element and its contents.
+
+  @method element
+  @for Ember.Templates.helpers
+  @public
+*/
+const element = internalHelper(({
+  positional,
+  named
+}) => {
+  return createComputeRef(() => {
+    let tagName = valueForRef(positional[0]);
+    return getElementDefinition(tagName);
+  }, null, 'element');
+});
+
+export { element as e };

package/dist/prod/packages/shared-chunks/{element-builder-CzXb9l1W.js → element-builder-CnlTPNyw.js}

@@ -1,9 +1,113 @@
-import { A as DOMOperations, B as isSafeString, F as normalizeStringValue, N as NS_SVG, b as CursorImpl, C as ConcreteBounds, i as clear } from './on-CersD7PL.js';
+import { e as expect, S as StackImpl } from './collections-C3Y8z_9v.js';
+import { C as ConcreteBounds, i as isSafeString, n as normalizeStringValue, a as CursorImpl, c as clear } from './normalize-D9jDJVGg.js';
+import { a as assert } from './assert-Zqc4wiAV.js';
 import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
-import { S as StackImpl, e as expect } from './collections-GpG8lT2g.js';
 import { registerDestructor, destroy } from '../@glimmer/destroyable/index.js';
-import './fragment-D7nBU9ae.js';
 import { a as castToBrowser } from './simple-cast-DCvJLSin.js';
+import { n as normalizeProperty } from './props-fiqxqhAH.js';
+
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const NS_MATHML = 'http://www.w3.org/1998/Math/MathML';
+const NS_SVG = 'http://www.w3.org/2000/svg';
+const INSERT_BEFORE_BEGIN = 'beforebegin';
+const INSERT_BEFORE_END = 'beforeend';
+
+// http://www.w3.org/TR/html/syntax.html#html-integration-point
+const SVG_INTEGRATION_POINTS = {
+  foreignObject: 1,
+  desc: 1,
+  title: 1
+};
+
+// http://www.w3.org/TR/html/syntax.html#adjust-svg-attributes
+// TODO: Adjust SVG attributes
+
+// http://www.w3.org/TR/html/syntax.html#parsing-main-inforeign
+// TODO: Adjust SVG elements
+
+// http://www.w3.org/TR/html/syntax.html#parsing-main-inforeign
+const BLACKLIST_TABLE = Object.create(null);
+class DOMOperations {
+  // Set by this.setupUselessElement() in constructor
+
+  constructor(document) {
+    this.document = document;
+    this.setupUselessElement();
+  }
+
+  // split into separate method so that NodeDOMTreeConstruction
+  // can override it.
+  setupUselessElement() {
+    this.uselessElement = this.document.createElement('div');
+  }
+  createElement(tag, context) {
+    let isElementInSVGNamespace, isHTMLIntegrationPoint, isElementInMathMlNamespace, ns;
+    if (context) {
+      isElementInSVGNamespace = context.namespaceURI === NS_SVG || tag === 'svg';
+      isElementInMathMlNamespace = context.namespaceURI === NS_MATHML || tag === 'math';
+      isHTMLIntegrationPoint = !!SVG_INTEGRATION_POINTS[context.tagName];
+    } else {
+      isElementInSVGNamespace = tag === 'svg';
+      isElementInMathMlNamespace = tag === 'math';
+      isHTMLIntegrationPoint = false;
+    }
+    if ((isElementInMathMlNamespace || isElementInSVGNamespace) && !isHTMLIntegrationPoint) {
+      // FIXME: This does not properly handle <font> with color, face, or
+      // size attributes, which is also disallowed by the spec. We should fix
+      // this.
+      if (BLACKLIST_TABLE[tag]) {
+        throw new Error(`Cannot create a ${tag} inside an SVG context`);
+      }
+      if (isElementInMathMlNamespace) {
+        ns = NS_MATHML;
+      } else {
+        ns = NS_SVG;
+      }
+      return this.document.createElementNS(ns, tag);
+    } else {
+      return this.document.createElement(tag);
+    }
+  }
+  insertBefore(parent, node, reference) {
+    parent.insertBefore(node, reference);
+  }
+  insertHTMLBefore(parent, nextSibling, html) {
+    if (html === '') {
+      const comment = this.createComment('');
+      parent.insertBefore(comment, nextSibling);
+      return new ConcreteBounds(parent, comment, comment);
+    }
+    const prev = nextSibling ? nextSibling.previousSibling : parent.lastChild;
+    let last;
+    if (nextSibling === null) {
+      parent.insertAdjacentHTML(INSERT_BEFORE_END, html);
+      last = expect(parent.lastChild);
+    } else if (nextSibling instanceof HTMLElement) {
+      nextSibling.insertAdjacentHTML('beforebegin', html);
+      last = expect(nextSibling.previousSibling);
+    } else {
+      // Non-element nodes do not support insertAdjacentHTML, so add an
+      // element and call it on that element. Then remove the element.
+      const {
+        uselessElement
+      } = this;
+      parent.insertBefore(uselessElement, nextSibling);
+      uselessElement.insertAdjacentHTML(INSERT_BEFORE_BEGIN, html);
+      last = expect(uselessElement.previousSibling);
+      parent.removeChild(uselessElement);
+    }
+    const first = expect(prev ? prev.nextSibling : parent.firstChild);
+    return new ConcreteBounds(parent, first, last);
+  }
+  createTextNode(text) {
+    return this.document.createTextNode(text);
+  }
+  createComment(data) {
+    return this.document.createComment(data);
+  }
+}
 
 class TreeConstruction extends DOMOperations {
   createElementNS(namespace, tag) {
@@ -19,90 +123,6 @@ class TreeConstruction extends DOMOperations {
 }
 const DOMTreeConstruction = TreeConstruction;
 
-/*
- * @method normalizeProperty
- * @param element {HTMLElement}
- * @param slotName {String}
- * @returns {Object} { name, type }
- */
-function normalizeProperty(element, slotName) {
-  let type, normalized;
-  if (slotName in element) {
-    normalized = slotName;
-    type = 'prop';
-  } else {
-    let lower = slotName.toLowerCase();
-    if (lower in element) {
-      type = 'prop';
-      normalized = lower;
-    } else {
-      type = 'attr';
-      normalized = slotName;
-    }
-  }
-  if (type === 'prop' && (normalized.toLowerCase() === 'style' || preferAttr(element.tagName, normalized))) {
-    type = 'attr';
-  }
-  return {
-    normalized,
-    type
-  };
-}
-
-// Properties that MUST be set as attributes because the DOM properties
-// are read-only or have type mismatches with the HTML attributes.
-//
-// element.form is a read-only DOM property on all form-associated elements
-// that returns the owning HTMLFormElement (or null). The HTML `form` attribute
-// (set via setAttribute) associates the element with a form by ID.
-// See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/form
-//      https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement/form
-const ATTR_OVERRIDES = {
-  INPUT: {
-    form: true,
-    // HTMLElement.autocorrect is a boolean DOM property, but the HTML attribute
-    // uses "on"/"off" strings. Setting `element.autocorrect = "off"` coerces to
-    // `true` (truthy string). Must use setAttribute for correct "on"/"off" behavior.
-    // See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/autocorrect
-    autocorrect: true,
-    // HTMLInputElement.list is a read-only DOM property that returns the associated
-    // HTMLDataListElement (or null). Must use setAttribute to set the datalist ID.
-    // See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/list
-    list: true
-  },
-  SELECT: {
-    form: true
-  },
-  OPTION: {
-    form: true
-  },
-  TEXTAREA: {
-    form: true
-  },
-  LABEL: {
-    form: true
-  },
-  FIELDSET: {
-    form: true
-  },
-  LEGEND: {
-    form: true
-  },
-  OBJECT: {
-    form: true
-  },
-  OUTPUT: {
-    form: true
-  },
-  BUTTON: {
-    form: true
-  }
-};
-function preferAttr(tagName, propName) {
-  let tag = ATTR_OVERRIDES[tagName.toUpperCase()];
-  return !!(tag && tag[propName.toLowerCase()]);
-}
-
 const badProtocols = ['javascript:', 'vbscript:'];
 const badTags = ['A', 'BODY', 'LINK', 'IMG', 'IFRAME', 'BASE', 'FORM'];
 const badTagsForDataURI = ['EMBED'];
@@ -765,10 +785,11 @@ class AppendingBlockList {
   }
   didAppendBounds(_bounds) {}
   finalize(_stack) {
+    assert(this.boundList.length > 0);
   }
 }
 function clientBuilder(env, cursor) {
   return NewTreeBuilder.forInitialRender(env, cursor);
 }
 
-export { DOMTreeConstruction as D, NewTreeBuilder as N, RemoteBlock as R, SimpleDynamicAttribute as S, DynamicAttribute as a, ResettableBlockImpl as b, clientBuilder as c, dynamicAttribute as d, normalizeProperty as n };
+export { BLACKLIST_TABLE as B, COMMENT_NODE as C, DOMTreeConstruction as D, ELEMENT_NODE as E, NewTreeBuilder as N, RemoteBlock as R, SimpleDynamicAttribute as S, TEXT_NODE as T, DynamicAttribute as a, ResettableBlockImpl as b, clientBuilder as c, dynamicAttribute as d, NS_SVG as e, DOMOperations as f };

package/dist/prod/packages/shared-chunks/env-DXxsTFkM.js

@@ -0,0 +1,158 @@
+/**
+  The hash of environment variables used to control various configuration
+  settings. To specify your own or override default settings, add the
+  desired properties to a global hash named `EmberENV` (or `ENV` for
+  backwards compatibility with earlier versions of Ember). The `EmberENV`
+  hash must be created before loading Ember.
+
+  @class EmberENV
+  @type Object
+  @public
+*/
+const ENV = {
+  ENABLE_OPTIONAL_FEATURES: false,
+  /**
+    Determines whether Ember should add to `Array`
+    native object prototypes, a few extra methods in order to provide a more
+    friendly API.
+     The behavior from setting this option to `true` was deprecated in Ember 5.10.
+     @property EXTEND_PROTOTYPES
+    @type Boolean
+    @default true
+    @for EmberENV
+    @private
+    @deprecated in v5.10
+  */
+  EXTEND_PROTOTYPES: {
+    Array: false
+  },
+  /**
+    The `LOG_STACKTRACE_ON_DEPRECATION` property, when true, tells Ember to log
+    a full stack trace during deprecation warnings.
+     @property LOG_STACKTRACE_ON_DEPRECATION
+    @type Boolean
+    @default true
+    @for EmberENV
+    @public
+  */
+  LOG_STACKTRACE_ON_DEPRECATION: true,
+  /**
+    The `LOG_VERSION` property, when true, tells Ember to log versions of all
+    dependent libraries in use.
+     @property LOG_VERSION
+    @type Boolean
+    @default true
+    @for EmberENV
+    @public
+  */
+  LOG_VERSION: true,
+  /**
+    The `LOG_INSPECTOR_HINT` property, when true, tells Ember to log a hint
+    suggesting the Ember Inspector browser extension when it is not detected.
+     @property LOG_INSPECTOR_HINT
+    @type Boolean
+    @default true
+    @for EmberENV
+    @public
+  */
+  LOG_INSPECTOR_HINT: true,
+  RAISE_ON_DEPRECATION: false,
+  STRUCTURED_PROFILE: false,
+  /**
+    Whether to perform extra bookkeeping needed to make the `captureRenderTree`
+    API work.
+     This has to be set before the ember JavaScript code is evaluated. This is
+    usually done by setting `window.EmberENV = { _DEBUG_RENDER_TREE: true };`
+    before the "vendor" `<script>` tag in `index.html`.
+     Setting the flag after Ember is already loaded will not work correctly. It
+    may appear to work somewhat, but fundamentally broken.
+     This is not intended to be set directly. Ember Inspector will enable the
+    flag on behalf of the user as needed.
+     This flag is always on in development mode.
+     The flag is off by default in production mode, due to the cost associated
+    with the the bookkeeping work.
+     The expected flow is that Ember Inspector will ask the user to refresh the
+    page after enabling the feature. It could also offer a feature where the
+    user add some domains to the "always on" list. In either case, Ember
+    Inspector will inject the code on the page to set the flag if needed.
+     @property _DEBUG_RENDER_TREE
+    @for EmberENV
+    @type Boolean
+    @default false
+    @private
+  */
+  _DEBUG_RENDER_TREE: false /* DEBUG */,
+  /**
+   Whether to force all deprecations to be enabled. This is used internally by
+   Ember to enable deprecations in tests. It is not intended to be set in
+   projects.
+    @property _ALL_DEPRECATIONS_ENABLED
+   @for EmberENV
+   @type Boolean
+   @default false
+   @private
+   */
+  _ALL_DEPRECATIONS_ENABLED: false,
+  /**
+   Override the version of ember-source used to determine when deprecations "break".
+   This is used internally by Ember to test with deprecated features "removed".
+   This is never intended to be set by projects.
+   @property _OVERRIDE_DEPRECATION_VERSION
+   @for EmberENV
+   @type string | null
+   @default null
+   @private
+   */
+  _OVERRIDE_DEPRECATION_VERSION: null,
+  /**
+    Whether the app defaults to using async observers.
+     This is not intended to be set directly, as the implementation may change in
+    the future. Use `@ember/optional-features` instead.
+     @property _DEFAULT_ASYNC_OBSERVERS
+    @for EmberENV
+    @type Boolean
+    @default false
+    @private
+  */
+  _DEFAULT_ASYNC_OBSERVERS: false,
+  /**
+    Controls the maximum number of scheduled rerenders without "settling". In general,
+    applications should not need to modify this environment variable, but please
+    open an issue so that we can determine if a better default value is needed.
+     @property _RERENDER_LOOP_LIMIT
+    @for EmberENV
+    @type number
+    @default 1000
+    @private
+   */
+  _RERENDER_LOOP_LIMIT: 1000,
+  FEATURES: {}
+};
+const EmberENV = globalThis.EmberENV;
+if (typeof EmberENV === 'object' && EmberENV !== null) {
+  for (let flag in EmberENV) {
+    if (!Object.prototype.hasOwnProperty.call(EmberENV, flag) || flag === 'EXTEND_PROTOTYPES' || flag === 'EMBER_LOAD_HOOKS') continue;
+    let defaultValue = ENV[flag];
+    if (defaultValue === true) {
+      ENV[flag] = EmberENV[flag] !== false;
+    } else if (defaultValue === false) {
+      ENV[flag] = EmberENV[flag] === true;
+    } else {
+      ENV[flag] = EmberENV[flag];
+    }
+  }
+  let {
+    FEATURES
+  } = EmberENV;
+  if (typeof FEATURES === 'object' && FEATURES !== null) {
+    for (let feature in FEATURES) {
+      if (!Object.prototype.hasOwnProperty.call(FEATURES, feature)) continue;
+      ENV.FEATURES[feature] = FEATURES[feature] === true;
+    }
+  }
+}
+function getENV() {
+  return ENV;
+}
+
+export { ENV as E, getENV as g };

package/dist/prod/packages/shared-chunks/events-DYrYz3V8.js

@@ -0,0 +1,174 @@
+import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import { a as setListeners } from './super-BBBjgF69.js';
+
+/**
+@module @ember/object
+*/
+
+
+/*
+  The event system uses a series of nested hashes to store listeners on an
+  object. When a listener is registered, or when an event arrives, these
+  hashes are consulted to determine which target and action pair to invoke.
+
+  The hashes are stored in the object's meta hash, and look like this:
+
+      // Object's meta hash
+      {
+        listeners: {       // variable name: `listenerSet`
+          "foo:change": [ // variable name: `actions`
+            target, method, once
+          ]
+        }
+      }
+
+*/
+
+/**
+  Add an event listener
+
+  @method addListener
+  @static
+  @for @ember/object/events
+  @param obj
+  @param {String} eventName
+  @param {Object|Function} target A target object or a function
+  @param {Function|String} method A function or the name of a function to be called on `target`
+  @param {Boolean} once A flag whether a function should only be called once
+  @public
+*/
+function addListener(obj, eventName, target, method, once, sync = true) {
+  if (!method && 'function' === typeof target) {
+    method = target;
+    target = null;
+  }
+  meta(obj).addToListeners(eventName, target, method, once === true, sync);
+}
+
+/**
+  Remove an event listener
+
+  Arguments should match those passed to `addListener`.
+
+  @method removeListener
+  @static
+  @for @ember/object/events
+  @param obj
+  @param {String} eventName
+  @param {Object|Function} target A target object or a function
+  @param {Function|String} method A function or the name of a function to be called on `target`
+  @public
+*/
+function removeListener(obj, eventName, targetOrFunction, functionOrName) {
+  let target, method;
+  if (typeof targetOrFunction === 'object') {
+    target = targetOrFunction;
+    method = functionOrName;
+  } else {
+    target = null;
+    method = targetOrFunction;
+  }
+  let m = meta(obj);
+  m.removeFromListeners(eventName, target, method);
+}
+
+/**
+  Send an event. The execution of suspended listeners
+  is skipped, and once listeners are removed. A listener without
+  a target is executed on the passed object. If an array of actions
+  is not passed, the actions stored on the passed object are invoked.
+
+  @method sendEvent
+  @static
+  @for @ember/object/events
+  @param obj
+  @param {String} eventName
+  @param {Array} params Optional parameters for each listener.
+  @return {Boolean} if the event was delivered to one or more actions
+  @public
+*/
+function sendEvent(obj, eventName, params, actions, _meta) {
+  if (actions === undefined) {
+    let meta = _meta === undefined ? peekMeta(obj) : _meta;
+    actions = meta !== null ? meta.matchingListeners(eventName) : undefined;
+  }
+  if (actions === undefined || actions.length === 0) {
+    return false;
+  }
+  for (let i = actions.length - 3; i >= 0; i -= 3) {
+    // looping in reverse for once listeners
+    let target = actions[i];
+    let method = actions[i + 1];
+    let once = actions[i + 2];
+    if (!method) {
+      continue;
+    }
+    if (once) {
+      removeListener(obj, eventName, target, method);
+    }
+    if (!target) {
+      target = obj;
+    }
+    let type = typeof method;
+    if (type === 'string' || type === 'symbol') {
+      method = target[method];
+    }
+    method.apply(target, params);
+  }
+  return true;
+}
+
+/**
+  @public
+  @method hasListeners
+  @static
+  @for @ember/object/events
+  @param obj
+  @param {String} eventName
+  @return {Boolean} if `obj` has listeners for event `eventName`
+*/
+function hasListeners(obj, eventName) {
+  let meta = peekMeta(obj);
+  if (meta === null) {
+    return false;
+  }
+  let matched = meta.matchingListeners(eventName);
+  return matched !== undefined && matched.length > 0;
+}
+
+/**
+  Define a property as a function that should be executed when
+  a specified event or events are triggered.
+
+  ``` javascript
+  import EmberObject from '@ember/object';
+  import { on } from '@ember/object/evented';
+  import { sendEvent } from '@ember/object/events';
+
+  let Job = EmberObject.extend({
+    logCompleted: on('completed', function() {
+      console.log('Job completed!');
+    })
+  });
+
+  let job = Job.create();
+
+  sendEvent(job, 'completed'); // Logs 'Job completed!'
+ ```
+
+  @method on
+  @static
+  @for @ember/object/evented
+  @param {String} eventNames*
+  @param {Function} func
+  @return {Function} the listener function, passed as last argument to on(...)
+  @public
+*/
+function on(...args) {
+  let func = args.pop();
+  let events = args;
+  setListeners(func, events);
+  return func;
+}
+
+export { addListener as a, hasListeners as h, on as o, removeListener as r, sendEvent as s };