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

package/dist/{prod/packages/shared-chunks/program-B7SJZ5NF.js → dev/packages/shared-chunks/program-DzAfcWFj.js}

@@ -1,4 +1,4 @@
-import { u as unwrap } from './collections-GpG8lT2g.js';
+import { u as unwrap } from './collections-DPkjqeA3.js';
 import { O as OPERAND_LEN_MASK, A as ARG_SHIFT, M as MACHINE_MASK, T as TYPE_MASK } from './flags-B9qxc-pB.js';
 
 class RuntimeOpImpl {

package/dist/dev/packages/shared-chunks/{program-context-sJz0oHOA.js → program-context-CqcQMsfa.js}

@@ -1,7 +1,7 @@
-import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, d as VM_APPEND_HTML_OP, e as VM_APPEND_TEXT_OP, f as VM_RESOLVE_CURRIED_COMPONENT_OP, g as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, h as VM_APPEND_SAFE_HTML_OP, i as VM_APPEND_DOCUMENT_FRAGMENT_OP, j as VM_APPEND_NODE_OP, k as VM_INVOKE_STATIC_OP } from './fragment-Cc5k9Oy4.js';
+import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, c as VM_APPEND_HTML_OP, d as VM_APPEND_TEXT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, g as VM_APPEND_SAFE_HTML_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP, j as VM_INVOKE_STATIC_OP } from './opcode-metadata-9iSW5JGP.js';
+import { $ as $s0 } from './registers-DoamZwaG.js';
 import { ContentType } from '../@glimmer/vm/index.js';
-import { $ as $s0 } from './registers-ylirb0dq.js';
-import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-BUPd6pkm.js';
+import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-DmGmwWPJ.js';
 
 class StdLib {
   constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {

package/dist/dev/packages/shared-chunks/property_get-CIBS9umw.js

@@ -0,0 +1,139 @@
+import { s as setProxy } from './is_proxy-Bzg0d4m4.js';
+import { isEmberArray } from '../@ember/array/-internals.js';
+import '../@ember/debug/index.js';
+import { w as track, u as isTracking, k as consumeTag } from './cache-B7dqAS38.js';
+import { t as tagFor } from './meta-BmRXesrk.js';
+import { C as Cache } from './cache-qDyqAcpg.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+const firstDotIndexCache = new Cache(1000, key => key.indexOf('.'));
+function isPath(path) {
+  return typeof path === 'string' && firstDotIndexCache.get(path) !== -1;
+}
+
+/**
+@module @ember/object
+*/
+
+const PROXY_CONTENT = Symbol('PROXY_CONTENT');
+let getPossibleMandatoryProxyValue;
+{
+  getPossibleMandatoryProxyValue = function getPossibleMandatoryProxyValue(obj, keyName) {
+    let content = obj[PROXY_CONTENT];
+    if (content === undefined) {
+      return obj[keyName];
+    } else {
+      /* global Reflect */
+      return Reflect.get(content, keyName, obj);
+    }
+  };
+}
+function hasUnknownProperty(val) {
+  return typeof val === 'object' && val !== null && typeof val.unknownProperty === 'function';
+}
+
+// ..........................................................
+// GET AND SET
+//
+// If we are on a platform that supports accessors we can use those.
+// Otherwise simulate accessors by looking up the property directly on the
+// object.
+
+/**
+  Gets the value of a property on an object. If the property is computed,
+  the function will be invoked. If the property is not defined but the
+  object implements the `unknownProperty` method then that will be invoked.
+
+  ```javascript
+  import { get } from '@ember/object';
+  get(obj, "name");
+  ```
+
+  You only need to use this method to retrieve properties if the property
+  might not be defined on the object and you want to respect the
+  `unknownProperty` handler. Otherwise you can access the property directly.
+
+  Note that if the object itself is `undefined`, this method will throw
+  an error.
+
+  @method get
+  @for @ember/object
+  @static
+  @param {Object} obj The object to retrieve from.
+  @param {String} keyName The property key to retrieve
+  @return {Object} the property value or `null`.
+  @public
+*/
+
+function get(obj, keyName) {
+  (!(arguments.length === 2) && assert(`Get must be called with two arguments; an object and a property key`, arguments.length === 2));
+  (!(obj !== undefined && obj !== null) && assert(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null));
+  (!(typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)) && assert(`The key provided to get must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)));
+  (!(typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0) && assert(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0));
+  return isPath(keyName) ? _getPath(obj, keyName) : _getProp(obj, keyName);
+}
+function _getProp(obj, keyName) {
+  if (obj == null) {
+    return;
+  }
+  let value;
+  if (typeof obj === 'object' || typeof obj === 'function') {
+    {
+      value = getPossibleMandatoryProxyValue(obj, keyName);
+    }
+    if (value === undefined && typeof obj === 'object' && !(keyName in obj) && hasUnknownProperty(obj)) {
+      value = obj.unknownProperty(keyName);
+    }
+    if (isTracking()) {
+      consumeTag(tagFor(obj, keyName));
+      if (Array.isArray(value) || isEmberArray(value)) {
+        // Add the tag of the returned value if it is an array, since arrays
+        // should always cause updates if they are consumed and then changed
+        consumeTag(tagFor(value, '[]'));
+      }
+    }
+  } else {
+    // SAFETY: It should be ok to access properties on any non-nullish value
+    value = obj[keyName];
+  }
+  return value;
+}
+function _getPath(obj, path, forSet) {
+  let parts = typeof path === 'string' ? path.split('.') : path;
+  for (let part of parts) {
+    if (obj === undefined || obj === null || obj.isDestroyed) {
+      return undefined;
+    }
+    if (forSet && (part === '__proto__' || part === 'constructor')) {
+      return;
+    }
+    obj = _getProp(obj, part);
+  }
+  return obj;
+}
+
+// Warm it up
+_getProp('foo', 'a');
+_getProp('foo', 1);
+_getProp({}, 'a');
+_getProp({}, 1);
+_getProp({
+  unknownProperty() {}
+}, 'a');
+_getProp({
+  unknownProperty() {}
+}, 1);
+get({}, 'foo');
+get({}, 'foo.bar');
+let fakeProxy = {};
+setProxy(fakeProxy);
+track(() => _getProp({}, 'a'));
+track(() => _getProp({}, 1));
+track(() => _getProp({
+  a: []
+}, 'a'));
+track(() => _getProp({
+  a: fakeProxy
+}, 'a'));
+
+export { PROXY_CONTENT as P, _getPath as _, getPossibleMandatoryProxyValue as a, _getProp as b, get as g, hasUnknownProperty as h, isPath as i };

package/dist/dev/packages/shared-chunks/{property_set-DaoZXGM5.js → property_set-D3PKyisF.js}

@@ -1,7 +1,9 @@
-import { b as setWithMandatorySetter, l as lookupDescriptor } from './mandatory-setter-DHZe7-kW.js';
+import { s as setWithMandatorySetter, l as lookupDescriptor } from './mandatory-setter-BpbAMTzV.js';
 import { t as toString } from './to-string-C7M8LBLH.js';
 import '../@ember/debug/index.js';
-import { m as isPath, _ as _getPath, o as COMPUTED_SETTERS, p as getPossibleMandatoryProxyValue, n as notifyPropertyChange } from './observers-Bj9qLVau.js';
+import { C as COMPUTED_SETTERS } from './decorator-B5Uh5NFI.js';
+import { i as isPath, _ as _getPath, a as getPossibleMandatoryProxyValue } from './property_get-CIBS9umw.js';
+import { n as notifyPropertyChange } from './computed-CJnghmXC.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 /**

package/dist/dev/packages/shared-chunks/props-fiqxqhAH.js

@@ -0,0 +1,85 @@
+/*
+ * @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()]);
+}
+
+export { normalizeProperty as n };

package/dist/dev/packages/shared-chunks/{reference-C3TKDRnP.js → reference-BoPB2LfI.js}

@@ -1,7 +1,6 @@
-import './debug-to-string-CFb7h0lY.js';
-import { i as isDict, e as expect } from './collections-D_nY_0UJ.js';
+import { i as isDict, e as expect } from './collections-DPkjqeA3.js';
 import { setProp, getProp } from '../@glimmer/global-context/index.js';
-import { CONSTANT_TAG, INITIAL, validateTag, track, valueForTag, consumeTag } from '../@glimmer/validator/index.js';
+import { b as CONSTANT_TAG, I as INITIAL, y as validateTag, w as track, z as valueForTag, k as consumeTag } from './cache-B7dqAS38.js';
 
 const REFERENCE = Symbol('REFERENCE');
 const CONSTANT = 0;
@@ -173,4 +172,4 @@ let createDebugAliasRef;
   };
 }
 
-export { FALSE_REFERENCE as F, NULL_REFERENCE as N, REFERENCE as R, TRUE_REFERENCE as T, UNDEFINED_REFERENCE as U, createConstRef as a, childRefFor as b, createComputeRef as c, createPrimitiveRef as d, createDebugAliasRef as e, isInvokableRef as f, childRefFromParts as g, createInvokableRef as h, isConstRef as i, createReadOnlyRef as j, createUnboundRef as k, isUpdatableRef as l, updateRef as u, valueForRef as v };
+export { FALSE_REFERENCE as F, NULL_REFERENCE as N, REFERENCE as R, TRUE_REFERENCE as T, UNDEFINED_REFERENCE as U, createComputeRef as a, isInvokableRef as b, createConstRef as c, isUpdatableRef as d, createPrimitiveRef as e, childRefFor as f, childRefFromParts as g, createDebugAliasRef as h, isConstRef as i, createInvokableRef as j, createReadOnlyRef as k, createUnboundRef as l, updateRef as u, valueForRef as v };

package/dist/dev/packages/shared-chunks/{registers-ylirb0dq.js → registers-DoamZwaG.js}

@@ -32,4 +32,4 @@ function isLowLevelRegister(register) {
   return register <= $sp;
 }
 
-export { $s0 as $, $pc as a, $ra as b, $fp as c, $sp as d, $v0 as e, $t1 as f, $t0 as g, $s1 as h, isLowLevelRegister as i };
+export { $s0 as $, $v0 as a, $t1 as b, $t0 as c, $s1 as d, $sp as e, $fp as f, $ra as g, $pc as h, isLowLevelRegister as i };

package/dist/{prod/packages/shared-chunks/rehydrate-builder-CUefZL4I.js → dev/packages/shared-chunks/rehydrate-builder-DdzXTaJk.js}

@@ -1,8 +1,8 @@
-import { C as ConcreteBounds, x as COMMENT_NODE, b as CursorImpl, y as TEXT_NODE, z as ELEMENT_NODE, N as NS_SVG } from './on-CLxdmpmk.js';
-import './fragment-D7nBU9ae.js';
-import { e as expect } from './collections-GpG8lT2g.js';
+import { N as NewTreeBuilder, R as RemoteBlock, C as COMMENT_NODE, T as TEXT_NODE, E as ELEMENT_NODE, e as NS_SVG } from './element-builder-kHVx0F__.js';
 import { c as castToSimple, a as castToBrowser } from './simple-cast-DCvJLSin.js';
-import { N as NewTreeBuilder, R as RemoteBlock } from './element-builder-BmLF0C-1.js';
+import { e as expect } from './collections-DPkjqeA3.js';
+import { a as assert } from './assert-CUCJBR2C.js';
+import { C as ConcreteBounds, a as CursorImpl } from './normalize-CKySQVU7.js';
 
 const SERIALIZATION_FIRST_NODE_STRING = '%+b:0%';
 function isSerializationFirstNode(node) {
@@ -381,6 +381,9 @@ class RehydrateTree extends NewTreeBuilder {
   }
   __pushRemoteElement(element, cursorId, insertBefore) {
     const marker = this.getMarker(castToBrowser(element), cursorId);
+    assert(!marker || marker.parentNode === element);
+
+    // when insertBefore is not present, we clear the element
     if (insertBefore === undefined) {
       while (element.firstChild !== null && element.firstChild !== marker) {
         this.remove(element.firstChild);