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

package/dist/dev/packages/@glimmer/vm/index.js

@@ -1,5 +1,5 @@
 export { A as ARG_SHIFT, I as InternalComponentCapabilities, I as InternalComponentCapability, M as MACHINE_MASK, a as MAX_SIZE, O as OPERAND_LEN_MASK, T as TYPE_MASK, b as TYPE_SIZE } from '../../shared-chunks/flags-B9qxc-pB.js';
-export { c as $fp, a as $pc, b as $ra, $ as $s0, h as $s1, d as $sp, g as $t0, f as $t1, e as $v0, i as isLowLevelRegister } from '../../shared-chunks/registers-ylirb0dq.js';
+export { f as $fp, h as $pc, g as $ra, $ as $s0, d as $s1, e as $sp, c as $t0, b as $t1, a as $v0, i as isLowLevelRegister } from '../../shared-chunks/registers-DoamZwaG.js';
 
 const ContentType = {
   Component: 0,

package/dist/dev/packages/@glimmer/wire-format/index.js

@@ -1,51 +1,5 @@
-const opcodes = {
-  Append: 1,
-  TrustingAppend: 2,
-  Comment: 3,
-  Modifier: 4,
-  StrictModifier: 5,
-  Block: 6,
-  StrictBlock: 7,
-  Component: 8,
-  OpenElement: 10,
-  OpenElementWithSplat: 11,
-  FlushElement: 12,
-  CloseElement: 13,
-  StaticAttr: 14,
-  DynamicAttr: 15,
-  ComponentAttr: 16,
-  AttrSplat: 17,
-  Yield: 18,
-  DynamicArg: 20,
-  StaticArg: 21,
-  TrustingDynamicAttr: 22,
-  TrustingComponentAttr: 23,
-  StaticComponentAttr: 24,
-  Debugger: 26,
-  Undefined: 27,
-  Call: 28,
-  Concat: 29,
-  GetSymbol: 30,
-  GetLexicalSymbol: 32,
-  GetStrictKeyword: 31,
-  GetFreeAsComponentOrHelperHead: 35,
-  GetFreeAsHelperHead: 37,
-  GetFreeAsModifierHead: 38,
-  GetFreeAsComponentHead: 39,
-  InElement: 40,
-  If: 41,
-  Each: 42,
-  Let: 44,
-  WithDynamicVars: 45,
-  InvokeComponent: 46,
-  HasBlock: 48,
-  HasBlockParams: 49,
-  Curry: 50,
-  Not: 51,
-  IfInline: 52,
-  GetDynamicVar: 53,
-  Log: 54
-};
+import { o as opcodes } from '../../shared-chunks/opcodes-CplRyHl_.js';
+export { W as WellKnownAttrNames, a as WellKnownTagNames } from '../../shared-chunks/well-known-_EVO9RaV.js';
 
 const resolution = {
   Strict: 0,
@@ -55,22 +9,6 @@ const resolution = {
   ResolveAsComponentHead: 7
 };
 
-const WellKnownAttrNames = {
-  class: 0,
-  id: 1,
-  value: 2,
-  name: 3,
-  type: 4,
-  style: 5,
-  href: 6
-};
-const WellKnownTagNames = {
-  div: 0,
-  span: 1,
-  p: 2,
-  a: 3
-};
-
 function is(variant) {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   return function (value) {
@@ -99,4 +37,4 @@ function isHelper(expr) {
 // Expressions
 const isGet = is(opcodes.GetSymbol);
 
-export { opcodes as SexpOpcodes, resolution as VariableResolutionContext, WellKnownAttrNames, WellKnownTagNames, getStringFromValue, is, isArgument, isAttribute, isFlushElement, isGet, isHelper, isStringLiteral };
+export { opcodes as SexpOpcodes, resolution as VariableResolutionContext, getStringFromValue, is, isArgument, isAttribute, isFlushElement, isGet, isHelper, isStringLiteral };

package/dist/dev/packages/ember/version.js

@@ -1,4 +1,4 @@
 // this file gets replaced with the real value during the build
-const VERSION = '7.1.0-alpha.3';
+const VERSION = '7.1.0-alpha.5';
 
 export { VERSION as default };

package/dist/dev/packages/ember-template-compiler/index.js

@@ -1,14 +1,14 @@
-import '../shared-chunks/fragment-Cc5k9Oy4.js';
-import '../shared-chunks/debug-to-string-CFb7h0lY.js';
-import '../@glimmer/wire-format/index.js';
-import { p as precompile$1 } from '../shared-chunks/compiler-D1leQ3Gl.js';
-export { a as _preprocess } from '../shared-chunks/compiler-D1leQ3Gl.js';
+import { p as precompile$1 } from '../shared-chunks/compiler-CXB_8GdR.js';
+export { a as _preprocess } from '../shared-chunks/compiler-CXB_8GdR.js';
 import '../@ember/debug/index.js';
 import { STRICT_MODE_KEYWORDS, STRICT_MODE_TRANSFORMS, RESOLUTION_MODE_TRANSFORMS } from '../@ember/template-compiler/lib/plugins/index.js';
-import '../shared-chunks/mandatory-setter-DHZe7-kW.js';
+import '../shared-chunks/get-debug-name-CSniHBsn.js';
+import '../shared-chunks/guid-Cbq2sNV_.js';
+import '../shared-chunks/super-BBBjgF69.js';
 import { C as Cache } from '../shared-chunks/cache-qDyqAcpg.js';
+import '../shared-chunks/mandatory-setter-BpbAMTzV.js';
 import { assert } from '../@ember/debug/lib/assert.js';
-export { b as _print } from '../shared-chunks/transform-resolutions-D-YtZ0_g.js';
+export { b as _print } from '../shared-chunks/transform-resolutions-h1ik8gqW.js';
 
 /*
   This diverges from `Ember.String.dasherize` so that`<XFoo />` can resolve to `x-foo`.

package/dist/dev/packages/shared-chunks/{alias-CSC0WIbj.js → alias-ZcMQckQV.js}

@@ -1,10 +1,14 @@
 import { meta } from '../@ember/-internals/meta/lib/meta.js';
+import inspect from '../@ember/debug/lib/inspect.js';
 import '../@ember/debug/index.js';
-import { tagMetaFor, tagFor, untrack, validateTag, updateTag as UPDATE_TAG, valueForTag, consumeTag } from '../@glimmer/validator/index.js';
-import { i as isElementDescriptor, G as makeComputedDecorator, B as descriptorForDecorator, I as ComputedDescriptor, J as CHAIN_PASS_THROUGH, g as get, K as getChainTagsForKey, L as finishLazyChains, d as defineProperty } from './observers-Bj9qLVau.js';
-import { s as set } from './property_set-DaoZXGM5.js';
+import { x as untrack, y as validateTag, U as UPDATE_TAG, z as valueForTag, k as consumeTag } from './cache-B7dqAS38.js';
+import { a as tagMetaFor, t as tagFor } from './meta-BmRXesrk.js';
+import { C as CHAIN_PASS_THROUGH, g as getChainTagsForKey, f as finishLazyChains } from './chain-tags-D6tuFUj_.js';
+import { i as isElementDescriptor, m as makeComputedDecorator, b as descriptorForDecorator, c as ComputedDescriptor } from './decorator-B5Uh5NFI.js';
+import { d as defineProperty } from './computed-CJnghmXC.js';
+import { g as get } from './property_get-CIBS9umw.js';
+import { s as set } from './property_set-D3PKyisF.js';
 import { assert } from '../@ember/debug/lib/assert.js';
-import inspect from '../@ember/debug/lib/inspect.js';
 
 function alias(altKey) {
   (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @alias as a decorator directly, but it requires a `altKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)))); // SAFETY: We passed in the impl for this class

package/dist/dev/packages/shared-chunks/api-AYt3zE12.js

@@ -0,0 +1,310 @@
+import { j as setInternalHelperManager, C as CustomHelperManager, s as setInternalComponentManager, k as setInternalModifierManager } from './api-WvJPuo9z.js';
+import { registerDestructor } from '../@glimmer/destroyable/index.js';
+import { c as createConstRef } from './reference-BoPB2LfI.js';
+import { a as argsProxyFor } from './args-proxy-BNLuRFlO.js';
+import { F as FROM_CAPABILITIES, b as buildCapabilities } from './capabilities-CZkuOqqC.js';
+import { a as castToBrowser } from './simple-cast-DCvJLSin.js';
+import { debugAssert } from '../@glimmer/global-context/index.js';
+import { x as untrack, n as createUpdatableTag } from './cache-B7dqAS38.js';
+
+const CAPABILITIES = {
+  dynamicLayout: false,
+  dynamicTag: false,
+  prepareArgs: false,
+  createArgs: true,
+  attributeHook: false,
+  elementHook: false,
+  createCaller: false,
+  dynamicScope: true,
+  updateHook: true,
+  createInstance: true,
+  wrapped: false,
+  willDestroy: false,
+  hasSubOwner: false
+};
+function componentCapabilities(managerAPI, options = {}) {
+  if (managerAPI !== '3.13') {
+    throw new Error('Invalid component manager compatibility specified');
+  }
+  let updateHook = Boolean(options.updateHook);
+  return buildCapabilities({
+    asyncLifeCycleCallbacks: Boolean(options.asyncLifecycleCallbacks),
+    destructor: Boolean(options.destructor),
+    updateHook
+  });
+}
+function hasAsyncLifeCycleCallbacks(delegate) {
+  return delegate.capabilities.asyncLifeCycleCallbacks;
+}
+function hasUpdateHook(delegate) {
+  return delegate.capabilities.updateHook;
+}
+function hasAsyncUpdateHook(delegate) {
+  return hasAsyncLifeCycleCallbacks(delegate) && hasUpdateHook(delegate);
+}
+function hasDestructors(delegate) {
+  return delegate.capabilities.destructor;
+}
+
+/**
+  The CustomComponentManager allows addons to provide custom component
+  implementations that integrate seamlessly into Ember. This is accomplished
+  through a delegate, registered with the custom component manager, which
+  implements a set of hooks that determine component behavior.
+
+  To create a custom component manager, instantiate a new CustomComponentManager
+  class and pass the delegate as the first argument:
+
+  ```js
+  let manager = new CustomComponentManager({
+    // ...delegate implementation...
+  });
+  ```
+
+  ## Delegate Hooks
+
+  Throughout the lifecycle of a component, the component manager will invoke
+  delegate hooks that are responsible for surfacing those lifecycle changes to
+  the end developer.
+
+  * `create()` - invoked when a new instance of a component should be created
+  * `update()` - invoked when the arguments passed to a component change
+  * `getContext()` - returns the object that should be
+*/
+class CustomComponentManager {
+  componentManagerDelegates = new WeakMap();
+  constructor(factory) {
+    this.factory = factory;
+  }
+  getDelegateFor(owner) {
+    let {
+      componentManagerDelegates
+    } = this;
+    let delegate = componentManagerDelegates.get(owner);
+    if (delegate === undefined) {
+      let {
+        factory
+      } = this;
+      delegate = factory(owner);
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      if (!FROM_CAPABILITIES.has(delegate.capabilities)) {
+        // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
+        throw new Error(`Custom component managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.13')\` (imported via \`import { capabilities } from '@ember/component';\`). Received: \`${JSON.stringify(delegate.capabilities
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        )}\` for: \`${delegate}\``);
+      }
+      componentManagerDelegates.set(owner, delegate);
+    }
+    return delegate;
+  }
+  create(owner, definition, vmArgs) {
+    let delegate = this.getDelegateFor(owner);
+    let args = argsProxyFor(vmArgs.capture(), 'component');
+    let component = delegate.createComponent(definition, args);
+    return new CustomComponentState(component, delegate, args);
+  }
+  getDebugName(definition) {
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    return typeof definition === 'function' ? definition.name : definition.toString();
+  }
+  update(bucket) {
+    let {
+      delegate
+    } = bucket;
+    if (hasUpdateHook(delegate)) {
+      let {
+        component,
+        args
+      } = bucket;
+      delegate.updateComponent(component, args);
+    }
+  }
+  didCreate({
+    component,
+    delegate
+  }) {
+    if (hasAsyncLifeCycleCallbacks(delegate)) {
+      delegate.didCreateComponent(component);
+    }
+  }
+  didUpdate({
+    component,
+    delegate
+  }) {
+    if (hasAsyncUpdateHook(delegate)) {
+      delegate.didUpdateComponent(component);
+    }
+  }
+  didRenderLayout() {}
+  didUpdateLayout() {}
+  getSelf({
+    component,
+    delegate
+  }) {
+    return createConstRef(delegate.getContext(component), 'this');
+  }
+  getDestroyable(bucket) {
+    const {
+      delegate
+    } = bucket;
+    if (hasDestructors(delegate)) {
+      const {
+        component
+      } = bucket;
+      registerDestructor(bucket, () => delegate.destroyComponent(component));
+      return bucket;
+    }
+    return null;
+  }
+  getCapabilities() {
+    return CAPABILITIES;
+  }
+}
+
+/**
+ * Stores internal state about a component instance after it's been created.
+ */
+class CustomComponentState {
+  constructor(component, delegate, args) {
+    this.component = component;
+    this.delegate = delegate;
+    this.args = args;
+  }
+}
+
+function modifierCapabilities(managerAPI, optionalFeatures = {}) {
+  debugAssert(managerAPI === '3.22', () => `Invalid modifier manager compatibility specified; you specified ${managerAPI}, but only '3.22' is supported.`);
+  return buildCapabilities({
+    disableAutoTracking: Boolean(optionalFeatures.disableAutoTracking)
+  });
+}
+/**
+  The CustomModifierManager allows addons to provide custom modifier
+  implementations that integrate seamlessly into Ember. This is accomplished
+  through a delegate, registered with the custom modifier manager, which
+  implements a set of hooks that determine modifier behavior.
+  To create a custom modifier manager, instantiate a new CustomModifierManager
+  class and pass the delegate as the first argument:
+
+  ```js
+  let manager = new CustomModifierManager({
+    // ...delegate implementation...
+  });
+  ```
+
+  ## Delegate Hooks
+
+  Throughout the lifecycle of a modifier, the modifier manager will invoke
+  delegate hooks that are responsible for surfacing those lifecycle changes to
+  the end developer.
+  * `createModifier()` - invoked when a new instance of a modifier should be created
+  * `installModifier()` - invoked when the modifier is installed on the element
+  * `updateModifier()` - invoked when the arguments passed to a modifier change
+  * `destroyModifier()` - invoked when the modifier is about to be destroyed
+*/
+class CustomModifierManager {
+  componentManagerDelegates = new WeakMap();
+  constructor(factory) {
+    this.factory = factory;
+  }
+  getDelegateFor(owner) {
+    let {
+      componentManagerDelegates
+    } = this;
+    let delegate = componentManagerDelegates.get(owner);
+    if (delegate === undefined) {
+      let {
+        factory
+      } = this;
+      delegate = factory(owner);
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      if (!FROM_CAPABILITIES.has(delegate.capabilities)) {
+        // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
+        throw new Error(`Custom modifier managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.22')\` (imported via \`import { capabilities } from '@ember/modifier';\`). Received: \`${JSON.stringify(delegate.capabilities
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        )}\` for: \`${delegate}\``);
+      }
+      componentManagerDelegates.set(owner, delegate);
+    }
+    return delegate;
+  }
+  create(owner, element, definition, capturedArgs) {
+    let delegate = this.getDelegateFor(owner);
+    let args = argsProxyFor(capturedArgs, 'modifier');
+    let instance = delegate.createModifier(definition, args);
+    let tag = createUpdatableTag();
+    let state;
+    state = {
+      tag,
+      element,
+      delegate,
+      args,
+      modifier: instance
+    };
+    registerDestructor(state, () => delegate.destroyModifier(instance, args));
+    return state;
+  }
+  getDebugName(definition) {
+    if (typeof definition === 'function') {
+      return definition.name || definition.toString();
+    } else {
+      return '<unknown>';
+    }
+  }
+  getDebugInstance({
+    modifier
+  }) {
+    return modifier;
+  }
+  getTag({
+    tag
+  }) {
+    return tag;
+  }
+  install({
+    element,
+    args,
+    modifier,
+    delegate
+  }) {
+    let {
+      capabilities
+    } = delegate;
+    if (capabilities.disableAutoTracking) {
+      untrack(() => delegate.installModifier(modifier, castToBrowser(element, 'ELEMENT'), args));
+    } else {
+      delegate.installModifier(modifier, castToBrowser(element), args);
+    }
+  }
+  update({
+    args,
+    modifier,
+    delegate
+  }) {
+    let {
+      capabilities
+    } = delegate;
+    if (capabilities.disableAutoTracking) {
+      untrack(() => delegate.updateModifier(modifier, args));
+    } else {
+      delegate.updateModifier(modifier, args);
+    }
+  }
+  getDestroyable(state) {
+    return state;
+  }
+}
+
+function setComponentManager(factory, obj) {
+  return setInternalComponentManager(new CustomComponentManager(factory), obj);
+}
+function setModifierManager(factory, obj) {
+  return setInternalModifierManager(new CustomModifierManager(factory), obj);
+}
+function setHelperManager(factory, obj) {
+  return setInternalHelperManager(new CustomHelperManager(factory), obj);
+}
+
+export { CustomComponentManager as C, CustomModifierManager as a, setHelperManager as b, componentCapabilities as c, setModifierManager as d, modifierCapabilities as m, setComponentManager as s };

package/dist/dev/packages/shared-chunks/{api-BqXkkT0p.js → api-WvJPuo9z.js}

@@ -1,10 +1,9 @@
 import { d as debugToString } from './debug-to-string-CFb7h0lY.js';
 import { debugAssert } from '../@glimmer/global-context/index.js';
 import { associateDestroyableChild } from '../@glimmer/destroyable/index.js';
-import '../@glimmer/validator/index.js';
-import { c as createComputeRef, a as createConstRef, U as UNDEFINED_REFERENCE } from './reference-C3TKDRnP.js';
-import { a as argsProxyFor } from './args-proxy-DgXMc9b5.js';
-import { F as FROM_CAPABILITIES, b as buildCapabilities } from './capabilities-O_xc7Yqk.js';
+import { a as createComputeRef, c as createConstRef, U as UNDEFINED_REFERENCE } from './reference-BoPB2LfI.js';
+import { a as argsProxyFor } from './args-proxy-BNLuRFlO.js';
+import { F as FROM_CAPABILITIES, b as buildCapabilities } from './capabilities-CZkuOqqC.js';
 
 function helperCapabilities(managerAPI, options = {}) {
   debugAssert(managerAPI === '3.23', () => `Invalid helper manager compatibility specified; you specified ${managerAPI}, but only '3.23' is supported.`);
@@ -244,4 +243,4 @@ function hasDefaultHelperManager(definition) {
   return typeof definition === 'function';
 }
 
-export { CustomHelperManager as C, hasDestroyable as a, hasInternalComponentManager as b, helperCapabilities as c, getInternalModifierManager as d, getInternalComponentManager as e, hasInternalHelperManager as f, getInternalHelperManager as g, hasValue as h, setInternalHelperManager as i, setInternalModifierManager as j, hasInternalModifierManager as k, setInternalComponentManager as s };
+export { CustomHelperManager as C, getInternalHelperManager as a, getInternalModifierManager as b, hasInternalComponentManager as c, hasInternalHelperManager as d, hasInternalModifierManager as e, hasValue as f, getInternalComponentManager as g, hasDestroyable as h, helperCapabilities as i, setInternalHelperManager as j, setInternalModifierManager as k, setInternalComponentManager as s };

package/dist/dev/packages/shared-chunks/{args-proxy-DgXMc9b5.js → args-proxy-BNLuRFlO.js}

@@ -1,7 +1,5 @@
-import '../@glimmer/global-context/index.js';
-import './debug-to-string-CFb7h0lY.js';
-import { track } from '../@glimmer/validator/index.js';
-import { v as valueForRef } from './reference-C3TKDRnP.js';
+import { v as valueForRef } from './reference-BoPB2LfI.js';
+import { w as track } from './cache-B7dqAS38.js';
 
 const CUSTOM_TAG_FOR = new WeakMap();
 function getCustomTagFor(obj) {

package/dist/dev/packages/shared-chunks/{array-D8PfjQHi.js → array-Bh_kUjzy.js}

@@ -1,6 +1,7 @@
 import '../@ember/debug/index.js';
 import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
-import { k as sendEvent, n as notifyPropertyChange, E as addListener, F as removeListener } from './observers-Bj9qLVau.js';
+import { s as sendEvent, a as addListener, r as removeListener } from './events-6aFVjD4k.js';
+import { n as notifyPropertyChange } from './computed-CJnghmXC.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {