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

package/dist/prod/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/prod/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/prod/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/prod/packages/ember-template-compiler/index.js

@@ -1,12 +1,10 @@
-import '../shared-chunks/fragment-D7nBU9ae.js';
-import '../@glimmer/wire-format/index.js';
-import { p as precompile$1 } from '../shared-chunks/compiler-Bbki2GT_.js';
-export { a as _preprocess, b as _print } from '../shared-chunks/compiler-Bbki2GT_.js';
-import '../@ember/-internals/environment/index.js';
+import { p as precompile$1 } from '../shared-chunks/compiler-DjQtTQGk.js';
+export { a as _preprocess, b as _print } from '../shared-chunks/compiler-DjQtTQGk.js';
+import '../shared-chunks/env-DXxsTFkM.js';
 import { STRICT_MODE_KEYWORDS, STRICT_MODE_TRANSFORMS, RESOLUTION_MODE_TRANSFORMS } from '../@ember/template-compiler/lib/plugins/index.js';
-import '../shared-chunks/super-Cm_a_cLQ.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/transform-resolutions-DR4GLmR2.js';
 
 /*
   This diverges from `Ember.String.dasherize` so that`<XFoo />` can resolve to `x-foo`.

package/dist/prod/packages/shared-chunks/{alias-BLBQkche.js → alias-CLuFeKoV.js}

@@ -1,11 +1,13 @@
 import { meta } from '../@ember/-internals/meta/lib/meta.js';
-import '../@ember/-internals/environment/index.js';
 import inspect from '../@ember/debug/lib/inspect.js';
-import { tagMetaFor, tagFor, untrack, validateTag, updateTag as UPDATE_TAG, valueForTag, consumeTag } from '../@glimmer/validator/index.js';
-import { C as CHAIN_PASS_THROUGH, g as get, k as getChainTagsForKey, l as finishLazyChains } from './observers-tZ2aOzr4.js';
-import { m as makeComputedDecorator, b as descriptorForDecorator, c as ComputedDescriptor } from './decorator-BdDDBUd2.js';
-import { d as defineProperty } from './namespace_search-Dcdalhj6.js';
-import { s as set } from './property_set-B2sZxeCw.js';
+import './env-DXxsTFkM.js';
+import { u as untrack, v as validateTag, U as UPDATE_TAG, d as valueForTag, a as consumeTag } from './cache-BIlOoPA7.js';
+import { a as tagMetaFor, t as tagFor } from './meta-B9mldqPL.js';
+import { C as CHAIN_PASS_THROUGH, g as getChainTagsForKey, f as finishLazyChains } from './chain-tags-BJqcuCM1.js';
+import { m as makeComputedDecorator, b as descriptorForDecorator, c as ComputedDescriptor } from './decorator-DBCISop4.js';
+import { d as defineProperty } from './computed-2Udcmflw.js';
+import { g as get } from './property_get-hWJ0nGhW.js';
+import { s as set } from './property_set-Dj5-ScWk.js';
 
 function alias(altKey) {
   return makeComputedDecorator(new AliasedProperty(altKey), AliasDecoratorImpl);

package/dist/prod/packages/shared-chunks/api-CM1trl_4.js

@@ -0,0 +1,289 @@
+import { j as setInternalHelperManager, C as CustomHelperManager, s as setInternalComponentManager, k as setInternalModifierManager } from './api-zh_k31vb.js';
+import { registerDestructor } from '../@glimmer/destroyable/index.js';
+import { c as createConstRef } from './reference-BshxG6wn.js';
+import { a as argsProxyFor } from './args-proxy-BDXbXCF9.js';
+import { b as buildCapabilities } from './capabilities-_5e35539.js';
+import { a as castToBrowser } from './simple-cast-DCvJLSin.js';
+import { u as untrack, c as createUpdatableTag } from './cache-BIlOoPA7.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 = {}) {
+  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);
+      componentManagerDelegates.set(owner, delegate);
+    }
+    return delegate;
+  }
+  create(owner, definition, vmArgs) {
+    let delegate = this.getDelegateFor(owner);
+    let args = argsProxyFor(vmArgs.capture());
+    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));
+  }
+  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 = {}) {
+  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);
+      componentManagerDelegates.set(owner, delegate);
+    }
+    return delegate;
+  }
+  create(owner, element, definition, capturedArgs) {
+    let delegate = this.getDelegateFor(owner);
+    let args = argsProxyFor(capturedArgs);
+    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/prod/packages/shared-chunks/{api-DtWa0ZaF.js → api-zh_k31vb.js}

@@ -1,8 +1,7 @@
 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-BNqcwZWH.js';
-import { a as argsProxyFor } from './args-proxy-Dl0A0YWI.js';
-import { b as buildCapabilities } from './capabilities-DXA-L0iT.js';
+import { a as createComputeRef, c as createConstRef, U as UNDEFINED_REFERENCE } from './reference-BshxG6wn.js';
+import { a as argsProxyFor } from './args-proxy-BDXbXCF9.js';
+import { b as buildCapabilities } from './capabilities-_5e35539.js';
 
 function helperCapabilities(managerAPI, options = {}) {
   return buildCapabilities({
@@ -197,4 +196,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/prod/packages/shared-chunks/{args-proxy-Dl0A0YWI.js → args-proxy-BDXbXCF9.js}

@@ -1,5 +1,5 @@
-import { track } from '../@glimmer/validator/index.js';
-import { v as valueForRef } from './reference-BNqcwZWH.js';
+import { v as valueForRef } from './reference-BshxG6wn.js';
+import { t as track } from './cache-BIlOoPA7.js';
 
 const CUSTOM_TAG_FOR = new WeakMap();
 function getCustomTagFor(obj) {

package/dist/prod/packages/shared-chunks/{array-kVQfzrQn.js → array-DHdr4__s.js}

@@ -1,7 +1,7 @@
-import '../@ember/-internals/environment/index.js';
+import './env-DXxsTFkM.js';
 import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
-import { s as sendEvent, e as addListener, f as removeListener } from './observers-tZ2aOzr4.js';
-import { n as notifyPropertyChange } from './namespace_search-Dcdalhj6.js';
+import { s as sendEvent, a as addListener, r as removeListener } from './events-970OxD6Q.js';
+import { n as notifyPropertyChange } from './computed-2Udcmflw.js';
 
 function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
   // if no args are passed assume everything changes

package/dist/prod/packages/shared-chunks/assert-CUCJBR2C.js

@@ -0,0 +1,19 @@
+// import Logger from './logger';
+
+function assert(test, msg) {
+}
+
+/**
+ * This constant exists to make it easier to differentiate normal logs from
+ * errant console.logs. LOGGER can be used outside of LOCAL_TRACE_LOGGING checks,
+ * and is meant to be used in the rare situation where a console.* call is
+ * actually appropriate.
+ */
+const LOGGER = console;
+function assertNever(value, desc = 'unexpected unreachable branch') {
+  LOGGER.log('unreachable', value);
+  LOGGER.log(`${desc} :: ${JSON.stringify(value)} (${value})`);
+  throw new Error(`code reached unreachable`);
+}
+
+export { assert as a, assertNever as b };