ember-source 4.5.0-alpha.2 → 4.5.0-alpha.5

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Ember Changelog
 
+## v3.28.9 (April 19, 2022)
+
+- [#20028](https://github.com/emberjs/ember.js/pull/20028) Fix a memory leak in the Router Service class
+
 ### v4.4.0-beta.1 (March 24, 2022)
 
 - [#19882](https://github.com/emberjs/ember.js/pull/19882) / [#20005](https://github.com/emberjs/ember.js/pull/20005) [FEATURE] Implement the `unique-id` helper per [RFC #0659](https://github.com/emberjs/rfcs/blob/master/text/0659-unique-id-helper.md).

package/build-metadata.json

@@ -1,6 +1,6 @@
 {
-  "version": "4.5.0-alpha.2",
+  "version": "4.5.0-alpha.5",
   "buildType": "tag",
-  "SHA": "4a7edf82df84be07abebaa9a104783a7563c0fa3",
-  "assetPath": "/tag/shas/4a7edf82df84be07abebaa9a104783a7563c0fa3.tgz"
+  "SHA": "6323e29b9bebcc797136869aadff11f4f1df9dc9",
+  "assetPath": "/tag/shas/6323e29b9bebcc797136869aadff11f4f1df9dc9.tgz"
 }

package/dist/dependencies/@glimmer/global-context.js

@@ -15,6 +15,8 @@ import { DEBUG } from '@glimmer/env';
  *
  */
 
+let FEATURE_DEFAULT_HELPER_MANAGER = true; //////////
+
 /**
  * Schedules a VM revalidation.
  *
@@ -108,6 +110,8 @@ let assert;
 let deprecate;
 let globalContextWasSet = false;
 function setGlobalContext(context) {
+  var _a;
+
   if (DEBUG) {
     if (globalContextWasSet) {
       throw new Error('Attempted to set the global context twice. This should only be set once.');
@@ -128,6 +132,10 @@ function setGlobalContext(context) {
   warnIfStyleNotTrusted = context.warnIfStyleNotTrusted;
   assert = context.assert;
   deprecate = context.deprecate;
+
+  if (typeof ((_a = context.FEATURES) === null || _a === void 0 ? void 0 : _a.DEFAULT_HELPER_MANAGER) === 'boolean') {
+    FEATURE_DEFAULT_HELPER_MANAGER = context.FEATURES.DEFAULT_HELPER_MANAGER;
+  }
 }
 let assertGlobalContextWasSet;
 let testOverrideGlobalContext;
@@ -180,4 +188,4 @@ if (DEBUG) {
 }
 
 export default setGlobalContext;
-export { scheduleRevalidate, scheduleDestroy, scheduleDestroyed, toIterator, toBool, getProp, setProp, getPath, setPath, warnIfStyleNotTrusted, assert, deprecate, assertGlobalContextWasSet, testOverrideGlobalContext };
+export { FEATURE_DEFAULT_HELPER_MANAGER, scheduleRevalidate, scheduleDestroy, scheduleDestroyed, toIterator, toBool, getProp, setProp, getPath, setPath, warnIfStyleNotTrusted, assert, deprecate, assertGlobalContextWasSet, testOverrideGlobalContext };

package/dist/dependencies/@glimmer/manager.js

@@ -1,115 +1,9 @@
 import { DEBUG } from '@glimmer/env';
-import { debugToString, _WeakSet, HAS_NATIVE_PROXY } from '@glimmer/util';
-import { valueForRef, createConstRef, createComputeRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
+import { _WeakSet, HAS_NATIVE_PROXY, debugToString } from '@glimmer/util';
+import { valueForRef, createComputeRef, createConstRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
 import { track, createUpdatableTag, untrack } from '@glimmer/validator';
-import { registerDestructor, associateDestroyableChild } from '@glimmer/destroyable';
-
-const COMPONENT_MANAGERS = new WeakMap();
-const MODIFIER_MANAGERS = new WeakMap();
-const HELPER_MANAGERS = new WeakMap(); ///////////
-
-const getPrototypeOf = Object.getPrototypeOf;
-
-function setManager(map, manager, obj) {
-  if (DEBUG && (typeof obj !== 'object' || obj === null) && typeof obj !== 'function') {
-    throw new Error(`Attempted to set a manager on a non-object value. Managers can only be associated with objects or functions. Value was ${debugToString(obj)}`);
-  }
-
-  if (DEBUG && map.has(obj)) {
-    throw new Error(`Attempted to set the same type of manager multiple times on a value. You can only associate one manager of each type with a given value. Value was ${debugToString(obj)}`);
-  }
-
-  map.set(obj, manager);
-  return obj;
-}
-
-function getManager(map, obj) {
-  let pointer = obj;
-
-  while (pointer !== undefined && pointer !== null) {
-    const manager = map.get(pointer);
-
-    if (manager !== undefined) {
-      return manager;
-    }
-
-    pointer = getPrototypeOf(pointer);
-  }
-
-  return undefined;
-} ///////////
-
-
-function setInternalModifierManager(manager, definition) {
-  return setManager(MODIFIER_MANAGERS, manager, definition);
-}
-function getInternalModifierManager(definition, isOptional) {
-  if (DEBUG && typeof definition !== 'function' && (typeof definition !== 'object' || definition === null)) {
-    throw new Error(`Attempted to use a value as a modifier, but it was not an object or function. Modifier definitions must be objects or functions with an associated modifier manager. The value was: ${definition}`);
-  }
-
-  const manager = getManager(MODIFIER_MANAGERS, definition);
-
-  if (manager === undefined) {
-    if (isOptional === true) {
-      return null;
-    } else if (DEBUG) {
-      throw new Error(`Attempted to load a modifier, but there wasn't a modifier manager associated with the definition. The definition was: ${debugToString(definition)}`);
-    }
-  }
-
-  return manager;
-}
-function setInternalHelperManager(manager, definition) {
-  return setManager(HELPER_MANAGERS, manager, definition);
-}
-function getInternalHelperManager(definition, isOptional) {
-  if (DEBUG && typeof definition !== 'function' && (typeof definition !== 'object' || definition === null)) {
-    throw new Error(`Attempted to use a value as a helper, but it was not an object or function. Helper definitions must be objects or functions with an associated helper manager. The value was: ${definition}`);
-  }
-
-  const manager = getManager(HELPER_MANAGERS, definition);
-
-  if (manager === undefined) {
-    if (isOptional === true) {
-      return null;
-    } else if (DEBUG) {
-      throw new Error(`Attempted to load a helper, but there wasn't a helper manager associated with the definition. The definition was: ${debugToString(definition)}`);
-    }
-  }
-
-  return manager;
-}
-function setInternalComponentManager(factory, obj) {
-  return setManager(COMPONENT_MANAGERS, factory, obj);
-}
-function getInternalComponentManager(definition, isOptional) {
-  if (DEBUG && typeof definition !== 'function' && (typeof definition !== 'object' || definition === null)) {
-    throw new Error(`Attempted to use a value as a component, but it was not an object or function. Component definitions must be objects or functions with an associated component manager. The value was: ${definition}`);
-  }
-
-  const manager = getManager(COMPONENT_MANAGERS, definition);
-
-  if (manager === undefined) {
-    if (isOptional === true) {
-      return null;
-    } else if (DEBUG) {
-      throw new Error(`Attempted to load a component, but there wasn't a component manager associated with the definition. The definition was: ${debugToString(definition)}`);
-    }
-  }
-
-  return manager;
-} ///////////
-
-function hasInternalComponentManager(definition) {
-  return getManager(COMPONENT_MANAGERS, definition) !== undefined;
-}
-function hasInternalHelperManager(definition) {
-  return getManager(HELPER_MANAGERS, definition) !== undefined;
-}
-function hasInternalModifierManager(definition) {
-  return getManager(MODIFIER_MANAGERS, definition) !== undefined;
-}
+import { associateDestroyableChild, registerDestructor } from '@glimmer/destroyable';
+import { FEATURE_DEFAULT_HELPER_MANAGER } from '@glimmer/global-context';
 
 const FROM_CAPABILITIES = DEBUG ? new _WeakSet() : undefined;
 function buildCapabilities(capabilities) {
@@ -291,7 +185,7 @@ if (HAS_NATIVE_PROXY) {
 
     if (DEBUG) {
       const setHandler = function (_target, prop) {
-        throw new Error(`You attempted to set ${String(prop)} on the arguments of a component, helper, or modifier. Arguments are immutable and cannot be updated directly, they always represent the values that is passed down. If you want to set default values, you should use a getter and local tracked state instead.`);
+        throw new Error(`You attempted to set ${String(prop)} on the arguments of a component, helper, or modifier. Arguments are immutable and cannot be updated directly; they always represent the values that are passed down. If you want to set default values, you should use a getter and local tracked state instead.`);
       };
 
       const forInDebugHandler = () => {
@@ -365,6 +259,277 @@ if (HAS_NATIVE_PROXY) {
   };
 }
 
+function helperCapabilities(managerAPI, options = {}) {
+  if (DEBUG && managerAPI !== '3.23') {
+    throw new Error('Invalid helper manager compatibility specified');
+  }
+
+  if (DEBUG && (!(options.hasValue || options.hasScheduledEffect) || options.hasValue && options.hasScheduledEffect)) {
+    throw new Error('You must pass either the `hasValue` OR the `hasScheduledEffect` capability when defining a helper manager. Passing neither, or both, is not permitted.');
+  }
+
+  if (DEBUG && options.hasScheduledEffect) {
+    throw new Error('The `hasScheduledEffect` capability has not yet been implemented for helper managers. Please pass `hasValue` instead');
+  }
+
+  return buildCapabilities({
+    hasValue: Boolean(options.hasValue),
+    hasDestroyable: Boolean(options.hasDestroyable),
+    hasScheduledEffect: Boolean(options.hasScheduledEffect)
+  });
+} ////////////
+
+function hasValue(manager) {
+  return manager.capabilities.hasValue;
+}
+function hasDestroyable(manager) {
+  return manager.capabilities.hasDestroyable;
+} ////////////
+
+class CustomHelperManager {
+  constructor(factory) {
+    this.factory = factory;
+    this.helperManagerDelegates = new WeakMap();
+    this.undefinedDelegate = null;
+  }
+
+  getDelegateForOwner(owner) {
+    let delegate = this.helperManagerDelegates.get(owner);
+
+    if (delegate === undefined) {
+      let {
+        factory
+      } = this;
+      delegate = factory(owner);
+
+      if (DEBUG && !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 helper managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.23')\` (imported via \`import { capabilities } from '@ember/helper';\`). Received: \`${JSON.stringify(delegate.capabilities)}\` for: \`${delegate}\``);
+      }
+
+      this.helperManagerDelegates.set(owner, delegate);
+    }
+
+    return delegate;
+  }
+
+  getDelegateFor(owner) {
+    if (owner === undefined) {
+      let {
+        undefinedDelegate
+      } = this;
+
+      if (undefinedDelegate === null) {
+        let {
+          factory
+        } = this;
+        this.undefinedDelegate = undefinedDelegate = factory(undefined);
+      }
+
+      return undefinedDelegate;
+    } else {
+      return this.getDelegateForOwner(owner);
+    }
+  }
+
+  getHelper(definition) {
+    return (capturedArgs, owner) => {
+      var _a, _b;
+
+      let manager = this.getDelegateFor(owner);
+      const args = argsProxyFor(capturedArgs, 'helper');
+      const bucket = manager.createHelper(definition, args);
+
+      if (hasValue(manager)) {
+        let cache = createComputeRef(() => manager.getValue(bucket), null, DEBUG && manager.getDebugName && manager.getDebugName(definition));
+
+        if (hasDestroyable(manager)) {
+          associateDestroyableChild(cache, manager.getDestroyable(bucket));
+        }
+
+        return cache;
+      } else if (hasDestroyable(manager)) {
+        let ref = createConstRef(undefined, DEBUG && ((_b = (_a = manager.getDebugName) === null || _a === void 0 ? void 0 : _a.call(manager, definition)) !== null && _b !== void 0 ? _b : 'unknown helper'));
+        associateDestroyableChild(ref, manager.getDestroyable(bucket));
+        return ref;
+      } else {
+        return UNDEFINED_REFERENCE;
+      }
+    };
+  }
+
+}
+
+class FunctionHelperManager {
+  constructor() {
+    this.capabilities = buildCapabilities({
+      hasValue: true,
+      hasDestroyable: false,
+      hasScheduledEffect: false
+    });
+  }
+
+  createHelper(fn, args) {
+    return {
+      fn,
+      args
+    };
+  }
+
+  getValue({
+    fn,
+    args
+  }) {
+    if (Object.keys(args.named).length > 0) {
+      let argsForFn = [...args.positional, args.named];
+      return fn(...argsForFn);
+    }
+
+    return fn(...args.positional);
+  }
+
+  getDebugName(fn) {
+    if (fn.name) {
+      return `(helper function ${fn.name})`;
+    }
+
+    return '(anonymous helper function)';
+  }
+
+}
+
+const COMPONENT_MANAGERS = new WeakMap();
+const MODIFIER_MANAGERS = new WeakMap();
+const HELPER_MANAGERS = new WeakMap(); ///////////
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function setManager(map, manager, obj) {
+  if (DEBUG && (typeof obj !== 'object' || obj === null) && typeof obj !== 'function') {
+    throw new Error(`Attempted to set a manager on a non-object value. Managers can only be associated with objects or functions. Value was ${debugToString(obj)}`);
+  }
+
+  if (DEBUG && map.has(obj)) {
+    throw new Error(`Attempted to set the same type of manager multiple times on a value. You can only associate one manager of each type with a given value. Value was ${debugToString(obj)}`);
+  }
+
+  map.set(obj, manager);
+  return obj;
+}
+
+function getManager(map, obj) {
+  let pointer = obj;
+
+  while (pointer !== undefined && pointer !== null) {
+    const manager = map.get(pointer);
+
+    if (manager !== undefined) {
+      return manager;
+    }
+
+    pointer = getPrototypeOf(pointer);
+  }
+
+  return undefined;
+} ///////////
+
+
+function setInternalModifierManager(manager, definition) {
+  return setManager(MODIFIER_MANAGERS, manager, definition);
+}
+function getInternalModifierManager(definition, isOptional) {
+  if (DEBUG && typeof definition !== 'function' && (typeof definition !== 'object' || definition === null)) {
+    throw new Error(`Attempted to use a value as a modifier, but it was not an object or function. Modifier definitions must be objects or functions with an associated modifier manager. The value was: ${definition}`);
+  }
+
+  const manager = getManager(MODIFIER_MANAGERS, definition);
+
+  if (manager === undefined) {
+    if (isOptional === true) {
+      return null;
+    } else if (DEBUG) {
+      throw new Error(`Attempted to load a modifier, but there wasn't a modifier manager associated with the definition. The definition was: ${debugToString(definition)}`);
+    }
+  }
+
+  return manager;
+}
+function setInternalHelperManager(manager, definition) {
+  return setManager(HELPER_MANAGERS, manager, definition);
+}
+const DEFAULT_MANAGER = new CustomHelperManager(() => new FunctionHelperManager());
+function getInternalHelperManager(definition, isOptional) {
+  if (DEBUG && typeof definition !== 'function' && (typeof definition !== 'object' || definition === null)) {
+    throw new Error(`Attempted to use a value as a helper, but it was not an object or function. Helper definitions must be objects or functions with an associated helper manager. The value was: ${definition}`);
+  }
+
+  let manager = getManager(HELPER_MANAGERS, definition);
+
+  if (FEATURE_DEFAULT_HELPER_MANAGER) {
+    // Functions are special-cased because functions are defined
+    // as the "default" helper, per: https://github.com/emberjs/rfcs/pull/756
+    if (manager === undefined && typeof definition === 'function') {
+      manager = DEFAULT_MANAGER;
+    }
+  }
+
+  if (manager) {
+    return manager;
+  } else if (isOptional === true) {
+    return null;
+  } else if (DEBUG) {
+    throw new Error(`Attempted to load a helper, but there wasn't a helper manager associated with the definition. The definition was: ${debugToString(definition)}`);
+  }
+
+  return null;
+}
+function setInternalComponentManager(factory, obj) {
+  return setManager(COMPONENT_MANAGERS, factory, obj);
+}
+function getInternalComponentManager(definition, isOptional) {
+  if (DEBUG && typeof definition !== 'function' && (typeof definition !== 'object' || definition === null)) {
+    throw new Error(`Attempted to use a value as a component, but it was not an object or function. Component definitions must be objects or functions with an associated component manager. The value was: ${definition}`);
+  }
+
+  const manager = getManager(COMPONENT_MANAGERS, definition);
+
+  if (manager === undefined) {
+    if (isOptional === true) {
+      return null;
+    } else if (DEBUG) {
+      throw new Error(`Attempted to load a component, but there wasn't a component manager associated with the definition. The definition was: ${debugToString(definition)}`);
+    }
+  }
+
+  return manager;
+} ///////////
+
+function hasInternalComponentManager(definition) {
+  return hasDefaultComponentManager(definition) || getManager(COMPONENT_MANAGERS, definition) !== undefined;
+}
+function hasInternalHelperManager(definition) {
+  return hasDefaultHelperManager(definition) || getManager(HELPER_MANAGERS, definition) !== undefined;
+}
+function hasInternalModifierManager(definition) {
+  return hasDefaultModifierManager(definition) || getManager(MODIFIER_MANAGERS, definition) !== undefined;
+}
+
+function hasDefaultComponentManager(_definition) {
+  return false;
+}
+
+function hasDefaultHelperManager(definition) {
+  if (FEATURE_DEFAULT_HELPER_MANAGER) {
+    return typeof definition === 'function';
+  }
+
+  return false;
+}
+
+function hasDefaultModifierManager(_definition) {
+  return false;
+}
+
 const CAPABILITIES = {
   dynamicLayout: false,
   dynamicTag: false,
@@ -683,107 +848,6 @@ class CustomModifierManager {
 
 }
 
-function helperCapabilities(managerAPI, options = {}) {
-  if (DEBUG && managerAPI !== '3.23') {
-    throw new Error('Invalid helper manager compatibility specified');
-  }
-
-  if (DEBUG && (!(options.hasValue || options.hasScheduledEffect) || options.hasValue && options.hasScheduledEffect)) {
-    throw new Error('You must pass either the `hasValue` OR the `hasScheduledEffect` capability when defining a helper manager. Passing neither, or both, is not permitted.');
-  }
-
-  if (DEBUG && options.hasScheduledEffect) {
-    throw new Error('The `hasScheduledEffect` capability has not yet been implemented for helper managers. Please pass `hasValue` instead');
-  }
-
-  return buildCapabilities({
-    hasValue: Boolean(options.hasValue),
-    hasDestroyable: Boolean(options.hasDestroyable),
-    hasScheduledEffect: Boolean(options.hasScheduledEffect)
-  });
-} ////////////
-
-function hasValue(manager) {
-  return manager.capabilities.hasValue;
-}
-function hasDestroyable(manager) {
-  return manager.capabilities.hasDestroyable;
-} ////////////
-
-class CustomHelperManager {
-  constructor(factory) {
-    this.factory = factory;
-    this.helperManagerDelegates = new WeakMap();
-    this.undefinedDelegate = null;
-  }
-
-  getDelegateForOwner(owner) {
-    let delegate = this.helperManagerDelegates.get(owner);
-
-    if (delegate === undefined) {
-      let {
-        factory
-      } = this;
-      delegate = factory(owner);
-
-      if (DEBUG && !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 helper managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.23')\` (imported via \`import { capabilities } from '@ember/helper';\`). Received: \`${JSON.stringify(delegate.capabilities)}\` for: \`${delegate}\``);
-      }
-
-      this.helperManagerDelegates.set(owner, delegate);
-    }
-
-    return delegate;
-  }
-
-  getDelegateFor(owner) {
-    if (owner === undefined) {
-      let {
-        undefinedDelegate
-      } = this;
-
-      if (undefinedDelegate === null) {
-        let {
-          factory
-        } = this;
-        this.undefinedDelegate = undefinedDelegate = factory(undefined);
-      }
-
-      return undefinedDelegate;
-    } else {
-      return this.getDelegateForOwner(owner);
-    }
-  }
-
-  getHelper(definition) {
-    return (capturedArgs, owner) => {
-      var _a, _b;
-
-      let manager = this.getDelegateFor(owner);
-      const args = argsProxyFor(capturedArgs, 'helper');
-      const bucket = manager.createHelper(definition, args);
-
-      if (hasValue(manager)) {
-        let cache = createComputeRef(() => manager.getValue(bucket), null, DEBUG && manager.getDebugName && manager.getDebugName(definition));
-
-        if (hasDestroyable(manager)) {
-          associateDestroyableChild(cache, manager.getDestroyable(bucket));
-        }
-
-        return cache;
-      } else if (hasDestroyable(manager)) {
-        let ref = createConstRef(undefined, DEBUG && ((_b = (_a = manager.getDebugName) === null || _a === void 0 ? void 0 : _a.call(manager, definition)) !== null && _b !== void 0 ? _b : 'unknown helper'));
-        associateDestroyableChild(ref, manager.getDestroyable(bucket));
-        return ref;
-      } else {
-        return UNDEFINED_REFERENCE;
-      }
-    };
-  }
-
-}
-
 function setComponentManager(factory, obj) {
   return setInternalComponentManager(new CustomComponentManager(factory), obj);
 }

package/dist/dependencies/@glimmer/runtime.js

@@ -6609,7 +6609,7 @@ var fn = internalHelper(({
 
 function assertCallbackIsFn(callbackRef) {
   if (!(callbackRef && (isInvokableRef(callbackRef) || typeof valueForRef(callbackRef) === 'function'))) {
-    throw new Error(`You must pass a function as the \`fn\` helpers first argument, you passed ${callbackRef ? valueForRef(callbackRef) : callbackRef}. While rendering:\n\n${callbackRef === null || callbackRef === void 0 ? void 0 : callbackRef.debugLabel}`);
+    throw new Error(`You must pass a function as the \`fn\` helper's first argument, you passed ${callbackRef ? valueForRef(callbackRef) : callbackRef}. While rendering:\n\n${callbackRef === null || callbackRef === void 0 ? void 0 : callbackRef.debugLabel}`);
   }
 }
 
@@ -6974,7 +6974,7 @@ class OnModifierState {
       let value = valueForRef(userProvidedCallbackReference);
 
       if (typeof value !== 'function') {
-        throw new Error(`You must pass a function as the second argument to the \`on\` modifier, you passed ${value === null ? 'null' : typeof value}. While rendering:\n\n${userProvidedCallbackReference.debugLabel}`);
+        throw new Error(`You must pass a function as the second argument to the \`on\` modifier; you passed ${value === null ? 'null' : typeof value}. While rendering:\n\n${userProvidedCallbackReference.debugLabel}`);
       }
     }
 

package/dist/dependencies/@glimmer/util.js

@@ -91,28 +91,7 @@ function isSerializationFirstNode(node) {
   return node.nodeValue === SERIALIZATION_FIRST_NODE_STRING;
 }
 
-var _a;
-
-const {
-  keys: objKeys
-} = Object;
-
-function assignFn(obj) {
-  for (let i = 1; i < arguments.length; i++) {
-    let assignment = arguments[i];
-    if (assignment === null || typeof assignment !== 'object') continue;
-    let keys = objKeys(assignment);
-
-    for (let j = 0; j < keys.length; j++) {
-      let key = keys[j];
-      obj[key] = assignment[key];
-    }
-  }
-
-  return obj;
-}
-
-let assign = (_a = Object.assign) !== null && _a !== void 0 ? _a : assignFn;
+let assign = Object.assign;
 function fillNulls(count) {
   let arr = new Array(count);