ember-source 6.12.0 → 7.0.0-alpha.1

package/dist/prod/packages/@glimmer/manager/index.js

@@ -0,0 +1,293 @@
+import { i as setInternalHelperManager, C as CustomHelperManager, s as setInternalComponentManager, j as setInternalModifierManager } from '../../shared-chunks/api-Co-k4HVs.js';
+export { e as getInternalComponentManager, g as getInternalHelperManager, d as getInternalModifierManager, a as hasDestroyable, b as hasInternalComponentManager, f as hasInternalHelperManager, k as hasInternalModifierManager, h as hasValue, c as helperCapabilities } from '../../shared-chunks/api-Co-k4HVs.js';
+import { registerDestructor } from '../destroyable/index.js';
+import { untrack, createUpdatableTag } from '../validator/index.js';
+import { a as createConstRef } from '../../shared-chunks/reference-BNqcwZWH.js';
+import { a as argsProxyFor } from '../../shared-chunks/args-proxy-Dl0A0YWI.js';
+export { g as getCustomTagFor, s as setCustomTagFor } from '../../shared-chunks/args-proxy-Dl0A0YWI.js';
+import { b as buildCapabilities } from '../../shared-chunks/capabilities-DGmQ_mz4.js';
+export { c as capabilityFlagsFrom, h as hasCapability, m as managerHasCapability } from '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { a as castToBrowser } from '../../shared-chunks/simple-cast-DCvJLSin.js';
+export { g as getComponentTemplate, s as setComponentTemplate } from '../../shared-chunks/template-Dc_cBOoX.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, CustomHelperManager, CustomModifierManager, componentCapabilities, modifierCapabilities, setComponentManager, setHelperManager, setInternalComponentManager, setInternalHelperManager, setInternalModifierManager, setModifierManager };

package/dist/{packages/shared-chunks/node-dom-helper-BYL7Plyj.js → prod/packages/@glimmer/node/index.js}

@@ -1,14 +1,12 @@
-import './capabilities-DHiXCCuB.js';
-import './debug-to-string-BsFOvUtQ.js';
-import '@embroider/macros';
-import '../@glimmer/global-context/index.js';
-import '../@glimmer/validator/index.js';
-import './reference-B6HMX4y0.js';
-import { C as ConcreteBounds } from './dynamic-CuBsUXX8.js';
-import './constants-oDhF27qL.js';
-import '../@glimmer/destroyable/index.js';
-import createHTMLDocument from '../@simple-dom/document/index.js';
-import { D as DOMTreeConstruction } from './element-builder-BuVym8EM.js';
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import { C as ConcreteBounds } from '../../shared-chunks/on-CrTl7JQU.js';
+import '../../shared-chunks/constants-b-2IVErl.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import createHTMLDocument from '../../@simple-dom/document/index.js';
+import { D as DOMTreeConstruction } from '../../shared-chunks/element-builder-CiLTrXD6.js';
+export { s as serializeBuilder } from '../../shared-chunks/serialize-builder-CVQ3q8rJ.js';
 
 class NodeDOMTreeConstruction extends DOMTreeConstruction {
   // Hides property on base class
@@ -36,4 +34,4 @@ class NodeDOMTreeConstruction extends DOMTreeConstruction {
   }
 }
 
-export { NodeDOMTreeConstruction as N };
+export { NodeDOMTreeConstruction };

package/dist/prod/packages/@glimmer/opcode-compiler/index.js

@@ -0,0 +1,40 @@
+export { E as EMPTY_BLOCKS, W as WrappedBuilder, c as compilable, b as compileStatements, I as invokeStaticBlock, d as invokeStaticBlockWithStack, m as meta, a as templateCacheCounters, e as templateCompilationContext, t as templateFactory } from '../../shared-chunks/index-CSVCFS_p.js';
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+export { E as EvaluationContextImpl, S as StdLib, c as compileStd } from '../../shared-chunks/program-context-C-JdYXRA.js';
+
+let debugCompiler;
+
+const DEFAULT_CAPABILITIES = {
+  dynamicLayout: true,
+  dynamicTag: true,
+  prepareArgs: true,
+  createArgs: true,
+  attributeHook: false,
+  elementHook: false,
+  dynamicScope: true,
+  createCaller: false,
+  updateHook: true,
+  createInstance: true,
+  wrapped: false,
+  willDestroy: false,
+  hasSubOwner: false
+};
+const MINIMAL_CAPABILITIES = {
+  dynamicLayout: false,
+  dynamicTag: false,
+  prepareArgs: false,
+  createArgs: false,
+  attributeHook: false,
+  elementHook: false,
+  dynamicScope: false,
+  createCaller: false,
+  updateHook: false,
+  createInstance: false,
+  wrapped: false,
+  willDestroy: false,
+  hasSubOwner: false
+};
+
+export { DEFAULT_CAPABILITIES, MINIMAL_CAPABILITIES, debugCompiler };

package/dist/prod/packages/@glimmer/owner/index.js

@@ -0,0 +1,19 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+const OWNER = Symbol('OWNER');
+/**
+  Framework objects in a Glimmer application may receive an owner object.
+  Glimmer is unopinionated about this owner, but will forward it through its
+  internal resolution system, and through its managers if it is provided.
+*/
+function getOwner(object) {
+  return object[OWNER];
+}
+
+/**
+  `setOwner` set's an object's owner
+*/
+function setOwner(object, owner) {
+  object[OWNER] = owner;
+}
+
+export { OWNER, getOwner, setOwner };

package/dist/prod/packages/@glimmer/program/index.js

@@ -0,0 +1,12 @@
+import { C as ConstantsImpl } from '../../shared-chunks/constants-b-2IVErl.js';
+import { a as ProgramHeapImpl } from '../../shared-chunks/program-B7SJZ5NF.js';
+export { P as ProgramImpl, R as RuntimeOpImpl } from '../../shared-chunks/program-B7SJZ5NF.js';
+
+function artifacts() {
+  return {
+    constants: new ConstantsImpl(),
+    heap: new ProgramHeapImpl()
+  };
+}
+
+export { ConstantsImpl, ProgramHeapImpl, artifacts };

package/dist/{packages/shared-chunks/iterable-BKS7az3P.js → prod/packages/@glimmer/reference/index.js}

@@ -1,10 +1,9 @@
-import { toIterator, getPath } from '../@glimmer/global-context/index.js';
-import { E as EMPTY_ARRAY } from './array-utils-CZQxrdD3.js';
-import { a as isIndexable } from './collections-B8me-ZlQ.js';
-import './debug-to-string-BsFOvUtQ.js';
-import { isDevelopingApp } from '@embroider/macros';
-import { dirtyTag as DIRTY_TAG, consumeTag, createTag } from '../@glimmer/validator/index.js';
-import { b as createComputeRef, v as valueForRef } from './reference-B6HMX4y0.js';
+import { toIterator, getPath } from '../global-context/index.js';
+import { E as EMPTY_ARRAY } from '../../shared-chunks/array-utils-CZQxrdD3.js';
+import { c as isIndexable } from '../../shared-chunks/collections-GpG8lT2g.js';
+import { dirtyTag as DIRTY_TAG, consumeTag, createTag } from '../validator/index.js';
+import { c as createComputeRef, v as valueForRef } from '../../shared-chunks/reference-BNqcwZWH.js';
+export { F as FALSE_REFERENCE, N as NULL_REFERENCE, R as REFERENCE, T as TRUE_REFERENCE, U as UNDEFINED_REFERENCE, b as childRefFor, f as childRefFromParts, a as createConstRef, g as createDebugAliasRef, h as createInvokableRef, d as createPrimitiveRef, j as createReadOnlyRef, k as createUnboundRef, i as isConstRef, e as isInvokableRef, l as isUpdatableRef, u as updateRef } from '../../shared-chunks/reference-BNqcwZWH.js';
 
 const NULL_IDENTITY = {};
 const KEY = (_, index) => index;
@@ -18,10 +17,12 @@ const IDENTITY = item => {
   return item;
 };
 function keyForPath(path) {
-  if (isDevelopingApp() && path[0] === '@') {
-    throw new Error(`invalid keypath: '${path}', valid keys: @index, @identity, or a path`);
-  }
-  return uniqueKeyFor(item => getPath(item, path));
+  return uniqueKeyFor(item => {
+    if (item === null || item === undefined) {
+      return item;
+    }
+    return getPath(item, path);
+  });
 }
 function makeKeyFor(key) {
   switch (key) {
@@ -200,4 +201,4 @@ class ArrayIterator {
   }
 }
 
-export { createIteratorRef as a, createIteratorItemRef as c };
+export { createComputeRef, createIteratorItemRef, createIteratorRef, valueForRef };

package/dist/prod/packages/@glimmer/runtime/index.js

@@ -0,0 +1,9 @@
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+export { C as ConcreteBounds, a as CurriedValue, b as CursorImpl, D as DOMChanges, E as EMPTY_ARGS, c as EMPTY_NAMED, d as EMPTY_POSITIONAL, e as IDOMChanges, T as TEMPLATE_ONLY_COMPONENT_MANAGER, f as TemplateOnlyComponent, g as TemplateOnlyComponentManager, h as array, i as clear, j as concat, k as createCapturedArgs, l as curry, m as fn, n as get, o as hash, p as isWhitespace, q as on, r as reifyArgs, s as reifyNamed, t as reifyPositional, u as resetDebuggerCallback, v as setDebuggerCallback, w as templateOnlyComponent } from '../../shared-chunks/on-CrTl7JQU.js';
+export { D as DOMTreeConstruction, a as DynamicAttribute, N as NewTreeBuilder, R as RemoteBlock, b as ResettableBlockImpl, S as SimpleDynamicAttribute, c as clientBuilder, d as dynamicAttribute, n as normalizeProperty } from '../../shared-chunks/element-builder-CiLTrXD6.js';
+export { D as DynamicScopeImpl, E as EnvironmentImpl, L as LowLevelVM, S as ScopeImpl, U as UpdatingVM, i as inTransaction, r as renderComponent, a as renderMain, b as renderSync, c as runtimeOptions } from '../../shared-chunks/render-C1ZnScKH.js';
+export { i as invokeHelper } from '../../shared-chunks/invoke-DxL00a1D.js';
+export { destroy, isDestroyed, isDestroying, registerDestructor } from '../destroyable/index.js';
+export { R as RehydrateTree, S as SERIALIZATION_FIRST_NODE_STRING, i as isSerializationFirstNode, r as rehydrationBuilder } from '../../shared-chunks/rehydrate-builder-CSn1aIO1.js';

package/dist/prod/packages/@glimmer/tracking/index.js

@@ -0,0 +1,115 @@
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../@ember/-internals/environment/index.js';
+import { createCache, getValue } from '../validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import '../../shared-chunks/observers-R1ZklwWy.js';
+export { t as tracked } from '../../shared-chunks/tracked-ChVNBE2f.js';
+
+// NOTE: copied from: https://github.com/glimmerjs/glimmer.js/pull/358
+// Both glimmerjs/glimmer.js and emberjs/ember.js have the exact same implementation
+// of @cached, so any changes made to one should also be made to the other
+
+
+/**
+ * @decorator
+ *
+  Gives the getter a caching behavior. The return value of the getter
+  will be cached until any of the properties it is entangled with
+  are invalidated. This is useful when a getter is expensive and
+  used very often.
+
+  For instance, in this `GuestList` class, we have the `sortedGuests`
+  getter that sorts the guests alphabetically:
+
+  ```javascript
+    import { tracked } from '@glimmer/tracking';
+
+    class GuestList {
+      @tracked guests = ['Zoey', 'Tomster'];
+
+      get sortedGuests() {
+        return this.guests.slice().sort()
+      }
+    }
+  ```
+
+  Every time `sortedGuests` is accessed, a new array will be created and sorted,
+  because JavaScript getters do not cache by default. When the guest list
+  is small, like the one in the example, this is not a problem. However, if
+  the guest list were to grow very large, it would mean that we would be doing
+  a large amount of work each time we accessed `sortedGuests`. With `@cached`,
+  we can cache the value instead:
+
+  ```javascript
+    import { tracked, cached } from '@glimmer/tracking';
+
+    class GuestList {
+      @tracked guests = ['Zoey', 'Tomster'];
+
+      @cached
+      get sortedGuests() {
+        return this.guests.slice().sort()
+      }
+    }
+  ```
+
+  Now the `sortedGuests` getter will be cached based on autotracking.
+  It will only rerun and create a new sorted array when the guests tracked
+  property is updated.
+
+
+  ### Tradeoffs
+
+  Overuse is discouraged.
+
+  In general, you should avoid using `@cached` unless you have confirmed that
+  the getter you are decorating is computationally expensive, since `@cached`
+  adds a small amount of overhead to the getter.
+  While the individual costs are small, a systematic use of the `@cached`
+  decorator can add up to a large impact overall in your app.
+  Many getters and tracked properties are only accessed once during rendering,
+  and then never rerendered, so adding `@cached` when unnecessary can
+  negatively impact performance.
+
+  Also, `@cached` may rerun even if the values themselves have not changed,
+  since tracked properties will always invalidate.
+  For example updating an integer value from `5` to an other `5` will trigger
+  a rerun of the cached properties building from this integer.
+
+  Avoiding a cache invalidation in this case is not something that can
+  be achieved on the `@cached` decorator itself, but rather when updating
+  the underlying tracked values, by applying some diff checking mechanisms:
+
+  ```javascript
+  if (nextValue !== this.trackedProp) {
+    this.trackedProp = nextValue;
+  }
+  ```
+
+  Here equal values won't update the property, therefore not triggering
+  the subsequent cache invalidations of the `@cached` properties who were
+  using this `trackedProp`.
+
+  Remember that setting tracked data should only be done during initialization, 
+  or as the result of a user action. Setting tracked data during render
+  (such as in a getter), is not supported.
+
+  @method cached
+  @static
+  @for @glimmer/tracking
+  @public
+ */
+const cached = (...args) => {
+  const [target, key, descriptor] = args;
+  const caches = new WeakMap();
+  const getter = descriptor.get;
+  descriptor.get = function () {
+    if (!caches.has(this)) {
+      caches.set(this, createCache(getter.bind(this)));
+    }
+    return getValue(caches.get(this));
+  };
+};
+
+export { cached };

package/dist/prod/packages/@glimmer/tracking/primitives/cache/index.js

@@ -0,0 +1,6 @@
+import '../../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../../@ember/-internals/environment/index.js';
+export { createCache, getValue, isConst } from '../../../validator/index.js';
+import '../../../../shared-chunks/reference-BNqcwZWH.js';
+import '../../../../shared-chunks/capabilities-DGmQ_mz4.js';
+import '../../../../shared-chunks/observers-R1ZklwWy.js';