ember-source 5.0.0 → 5.1.0-alpha.2

package/dist/header/license.js

@@ -5,5 +5,5 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   5.0.0
+ * @version   5.1.0-alpha.2
  */

package/dist/packages/@ember/-internals/glimmer/index.js

@@ -3,7 +3,7 @@ export { templateFactory as template, templateCacheCounters } from '@glimmer/opc
 import { hasDOM } from '@ember/-internals/browser-environment';
 import { assert, warn, debugFreeze, inspect, deprecate } from '@ember/debug';
 import { action as action$1 } from '@ember/object';
-import { isConstRef, valueForRef, createConstRef, isUpdatableRef, updateRef, createComputeRef, createPrimitiveRef, childRefFor, childRefFromParts, isInvokableRef, createUnboundRef, createInvokableRef, createReadOnlyRef, createDebugAliasRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
+import { valueForRef, isConstRef, createConstRef, isUpdatableRef, updateRef, createComputeRef, createPrimitiveRef, childRefFor, childRefFromParts, isInvokableRef, createUnboundRef, createInvokableRef, createReadOnlyRef, createDebugAliasRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
 import { untrack, createCache, consumeTag, tagFor, getValue, valueForTag, beginUntrackFrame, endUntrackFrame, beginTrackFrame, endTrackFrame, validateTag, createTag, dirtyTag, CONSTANT_TAG, isTracking, setTrackingTransactionEnv, createUpdatableTag, CURRENT_TAG } from '@glimmer/validator';
 import { tracked, get, PROPERTY_DID_CHANGE, tagForObject, objectAt, tagForProperty, _getProp, _setProp, set } from '@ember/-internals/metal';
 import { setOwner, getOwner, isFactory } from '@ember/-internals/owner';
@@ -462,7 +462,7 @@ if (hasDOM) {
   @param {Hash} options
   @public
 */
-class Input extends AbstractInput {
+class _Input extends AbstractInput {
   constructor() {
     super(...arguments);
     this._checked = valueFrom(this.args.named['checked']);
@@ -532,10 +532,10 @@ class Input extends AbstractInput {
     return supportedArguments.indexOf(name) !== -1 || super.isSupportedArgument(name);
   }
 }
-__decorate$1([action$1], Input.prototype, "change", null);
-__decorate$1([action$1], Input.prototype, "input", null);
-__decorate$1([action$1], Input.prototype, "checkedDidChange", null);
-var Input$1 = opaquify(Input, InputTemplate);
+__decorate$1([action$1], _Input.prototype, "change", null);
+__decorate$1([action$1], _Input.prototype, "input", null);
+__decorate$1([action$1], _Input.prototype, "checkedDidChange", null);
+const Input = opaquify(_Input, InputTemplate);
 
 var LinkToTemplate = templateFactory({
   "id": "CVwkBtGh",
@@ -793,7 +793,7 @@ function isQueryParams(value) {
   @see {Ember.Templates.components.LinkTo}
   @public
 **/
-class LinkTo extends InternalComponent {
+class _LinkTo extends InternalComponent {
   constructor() {
     super(...arguments);
     // GH #17963
@@ -1020,11 +1020,11 @@ class LinkTo extends InternalComponent {
     return supportedArguments.indexOf(name) !== -1 || super.isSupportedArgument(name);
   }
 }
-__decorate$2([service('-routing')], LinkTo.prototype, "routing", void 0);
-__decorate$2([action$1], LinkTo.prototype, "click", null);
+__decorate$2([service('-routing')], _LinkTo.prototype, "routing", void 0);
+__decorate$2([action$1], _LinkTo.prototype, "click", null);
 let {
   prototype
-} = LinkTo;
+} = _LinkTo;
 let descriptorFor = (target, property) => {
   if (target) {
     return Object.getOwnPropertyDescriptor(target, property) || descriptorFor(Object.getPrototypeOf(target), property);
@@ -1105,7 +1105,7 @@ let descriptorFor = (target, property) => {
     }
   });
 }
-var LinkTo$1 = opaquify(LinkTo, LinkToTemplate);
+const LinkTo = opaquify(_LinkTo, LinkToTemplate);
 
 var TextareaTemplate = templateFactory({
   "id": "OpzctQXz",
@@ -1252,7 +1252,7 @@ var __decorate$3 = undefined && undefined.__decorate || function (decorators, ta
   @see {Ember.Templates.components.Textarea}
   @public
 **/
-class Textarea extends AbstractInput {
+class _Textarea extends AbstractInput {
   static toString() {
     return 'Textarea';
   }
@@ -1271,9 +1271,9 @@ class Textarea extends AbstractInput {
     return supportedArguments.indexOf(name) !== -1 || super.isSupportedArgument(name);
   }
 }
-__decorate$3([action$1], Textarea.prototype, "change", null);
-__decorate$3([action$1], Textarea.prototype, "input", null);
-var Textarea$1 = opaquify(Textarea, TextareaTemplate);
+__decorate$3([action$1], _Textarea.prototype, "change", null);
+__decorate$3([action$1], _Textarea.prototype, "input", null);
+const Textarea = opaquify(_Textarea, TextareaTemplate);
 
 function isTemplateFactory(template) {
   return typeof template === 'function';
@@ -2336,49 +2336,6 @@ class Component extends CoreView.extend(ChildViewsSupport, ViewStateSupport, Cla
 Component.isComponentFactory = true;
 // We continue to use reopenClass here so that positionalParams can be overridden with reopenClass in subclasses.
 Component.reopenClass({
-  /**
-   Enables components to take a list of parameters as arguments.
-    For example, a component that takes two parameters with the names
-    `name` and `age`:
-       ```app/components/my-component.js
-    import Component from '@ember/component';
-       let MyComponent = Component.extend();
-       MyComponent.reopenClass({
-      positionalParams: ['name', 'age']
-    });
-       export default MyComponent;
-    ```
-       It can then be invoked like this:
-       ```hbs
-    {{my-component "John" 38}}
-    ```
-       The parameters can be referred to just like named parameters:
-       ```hbs
-    Name: {{name}}, Age: {{age}}.
-    ```
-       Using a string instead of an array allows for an arbitrary number of
-    parameters:
-       ```app/components/my-component.js
-    import Component from '@ember/component';
-       let MyComponent = Component.extend();
-       MyComponent.reopenClass({
-      positionalParams: 'names'
-    });
-       export default MyComponent;
-    ```
-       It can then be invoked like this:
-       ```hbs
-    {{my-component "John" "Michael" "Scott"}}
-    ```
-    The parameters can then be referred to by enumerating over the list:
-       ```hbs
-    {{#each names as |name|}}{{name}}{{/each}}
-    ```
-       @static
-    @public
-    @property positionalParams
-    @since 1.13.0
-    */
   positionalParams: []
 });
 setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
@@ -2389,29 +2346,6 @@ setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
 var _a;
 const RECOMPUTE_TAG = Symbol('RECOMPUTE_TAG');
 const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
-/**
-  In many cases it is not necessary to use the full `Helper` class.
-  The `helper` method create pure-function helpers without instances.
-  For example:
-
-  ```app/helpers/format-currency.js
-  import { helper } from '@ember/component/helper';
-
-  export default helper(function([cents], {currency}) {
-    return `${currency}${cents * 0.01}`;
-  });
-  ```
-
-  @static
-  @param {Function} helper The helper function
-  @method helper
-  @for @ember/component/helper
-  @public
-  @since 1.13.0
-*/
-function helper(helperFn) {
-  return new Wrapper(helperFn);
-}
 class Helper extends FrameworkObject {
   init(properties) {
     super.init(properties);
@@ -2453,6 +2387,7 @@ Helper[_a] = true;
 // here, but it should definitely be reviewed and probably removed.
 /** @deprecated */
 Helper.helper = helper;
+/* eslint-enable import/export */
 function isClassicHelper(obj) {
   return obj[IS_CLASSIC_HELPER] === true;
 }
@@ -2528,10 +2463,7 @@ class SimpleClassicHelperManager {
     });
   }
   createHelper(definition, args) {
-    let {
-      compute
-    } = definition;
-    return () => compute.call(null, args.positional, args.named);
+    return () => definition.compute.call(null, args.positional, args.named);
   }
   getValue(fn) {
     return fn();
@@ -2542,6 +2474,29 @@ class SimpleClassicHelperManager {
 }
 const SIMPLE_CLASSIC_HELPER_MANAGER = new SimpleClassicHelperManager();
 setHelperManager(() => SIMPLE_CLASSIC_HELPER_MANAGER, Wrapper.prototype);
+function helper(helperFn
+// At the implementation site, we don't care about the actual underlying type
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+  // SAFETY: this is completely lies, in two ways:
+  //
+  // 1. `Wrapper` is a `Factory<SimpleHelper<S>>`, but from the perspective of
+  //    any external callers (i.e. Ember *users*), it is quite important that
+  //    the `Factory` relationship be hidden, because it is not public API for
+  //    an end user to call `.create()` on a helper created this way. Instead,
+  //    we provide them an `abstract new` signature (which means it cannot be
+  //    directly constructed by calling `new` on it) and which does not have the
+  //    `.create()` signature on it anymore.
+  //
+  // 2. The produced type here ends up being a subtype of `Helper`, which is not
+  //    strictly true. This is necessary for the sake of Glint, which provides
+  //    its information by way of a "declaration merge" with `Helper<S>` in the
+  //    case of items produced by `helper()`.
+  //
+  // Long-term, this entire construct can go away in favor of deprecating the
+  // `helper()` invocation in favor of using plain functions.
+  return new Wrapper(helperFn);
+}
 
 /**
 @module @ember/template
@@ -5022,9 +4977,9 @@ function setupEngineRegistry(registry) {
   registry.optionsForType('helper', {
     instantiate: false
   });
-  registry.register('component:input', Input$1);
-  registry.register('component:link-to', LinkTo$1);
-  registry.register('component:textarea', Textarea$1);
+  registry.register('component:input', Input);
+  registry.register('component:link-to', LinkTo);
+  registry.register('component:textarea', Textarea);
   if (!ENV._TEMPLATE_ONLY_GLIMMER_COMPONENTS) {
     registry.register(privatize`component:-default`, Component);
   }
@@ -5047,4 +5002,4 @@ function setComponentManager(manager, obj) {
 let componentCapabilities = componentCapabilities$1;
 let modifierCapabilities = modifierCapabilities$1;
 
-export { Component, Helper, Input$1 as Input, LinkTo$1 as LinkTo, OutletView, Renderer, RootTemplate, SafeString, Textarea$1 as Textarea, _resetRenderers, componentCapabilities, escapeExpression, getTemplate, getTemplates, hasTemplate, helper, htmlSafe, isHTMLSafe, modifierCapabilities, renderSettled, setComponentManager, setTemplate, setTemplates, setupApplicationRegistry, setupEngineRegistry };
+export { Component, Helper, Input, LinkTo, OutletView, Renderer, RootTemplate, SafeString, Textarea, _resetRenderers, componentCapabilities, escapeExpression, getTemplate, getTemplates, hasTemplate, helper, htmlSafe, isHTMLSafe, modifierCapabilities, renderSettled, setComponentManager, setTemplate, setTemplates, setupApplicationRegistry, setupEngineRegistry };

package/dist/packages/@ember/-internals/metal/index.js

@@ -1369,44 +1369,6 @@ class ComputedDecoratorImpl extends Function {
     desc._readOnly = true;
     return this;
   }
-  /**
-    In some cases, you may want to annotate computed properties with additional
-    metadata about how they function or what values they operate on. For example,
-    computed property functions may close over variables that are then no longer
-    available for introspection. You can pass a hash of these values to a
-    computed property.
-       Example:
-       ```javascript
-    import { computed } from '@ember/object';
-    import Person from 'my-app/utils/person';
-       class Store {
-      @computed().meta({ type: Person })
-      get person() {
-        let personId = this.personId;
-        return Person.create({ id: personId });
-      }
-    }
-    ```
-       Classic Class Example:
-       ```javascript
-    import { computed } from '@ember/object';
-    import Person from 'my-app/utils/person';
-       const Store = EmberObject.extend({
-      person: computed(function() {
-        let personId = this.get('personId');
-        return Person.create({ id: personId });
-      }).meta({ type: Person })
-    });
-    ```
-       The hash that you pass to the `meta()` function will be saved on the
-    computed property descriptor under the `_meta` key. Ember runtime
-    exposes a public API for retrieving these values from classes,
-    via the `metaForProperty()` function.
-       @method meta
-    @param {Object} meta
-    @chainable
-    @public
-  */
   meta(meta) {
     let prop = descriptorForDecorator(this);
     if (arguments.length === 0) {
@@ -1961,38 +1923,14 @@ function getProperties(obj, keys) {
     propertyNames = Array.from(arguments);
   }
   for (; i < propertyNames.length; i++) {
-    ret[propertyNames[i]] = get(obj, propertyNames[i]);
+    // SAFETY: we are just walking the list of property names, so we know the
+    // index access never produces `undefined`.
+    let name = propertyNames[i];
+    ret[name] = get(obj, name);
   }
   return ret;
 }
 
-/**
- @module @ember/object
-*/
-/**
-  Set a list of properties on an object. These properties are set inside
-  a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-  observers will be buffered.
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  let anObject = EmberObject.create();
-
-  anObject.setProperties({
-    firstName: 'Stanley',
-    lastName: 'Stuart',
-    age: 21
-  });
-  ```
-
-  @method setProperties
-  @static
-  @for @ember/object
-  @param obj
-  @param {Object} properties
-  @return properties
-  @public
-*/
 function setProperties(obj, properties) {
   if (properties === null || typeof properties !== 'object') {
     return properties;
@@ -2000,6 +1938,9 @@ function setProperties(obj, properties) {
   changeProperties(() => {
     let props = Object.keys(properties);
     for (let propertyName of props) {
+      // SAFETY: casting `properties` this way is safe because any object in JS
+      // can be indexed this way, and the result will be `unknown`, making it
+      // safe for callers.
       set(obj, propertyName, properties[propertyName]);
     }
   });

package/dist/packages/@ember/-internals/utility-types/index.js

@@ -1 +1 @@
-export {};
+export class Opaque {}

package/dist/packages/@ember/array/proxy.js

@@ -150,7 +150,6 @@ class ArrayProxy extends EmberObject {
   }
   _addArrangedContentArrayObserver(arrangedContent) {
     if (arrangedContent && !arrangedContent.isDestroyed) {
-      // @ts-expect-error This check is still good for ensuring correctness
       assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
       assert(`ArrayProxy expects a native Array, EmberArray, or ArrayProxy, but you passed ${typeof arrangedContent}`, function (arr) {
         return Array.isArray(arr) || EmberArray.detect(arr);

package/dist/packages/@ember/component/template-only.js

@@ -2,30 +2,18 @@
   @module @ember/component/template-only
   @public
 */
-/**
-  This utility function is used to declare a given component has no backing class. When the rendering engine detects this it
-  is able to perform a number of optimizations. Templates that are associated with `templateOnly()` will be rendered _as is_
-  without adding a wrapping `<div>` (or any of the other element customization behaviors of [@ember/component](/ember/release/classes/Component)).
-  Specifically, this means that the template will be rendered as "outer HTML".
-
-  In general, this method will be used by build time tooling and would not be directly written in an application. However,
-  at times it may be useful to use directly to leverage the "outer HTML" semantics mentioned above. For example, if an addon would like
-  to use these semantics for its templates but cannot be certain it will only be consumed by applications that have enabled the
-  `template-only-glimmer-components` optional feature.
-
-  @example
-
-  ```js
-  import templateOnly from '@ember/component/template-only';
-
-  export default templateOnly();
-  ```
-
-  @public
-  @static
-  @method templateOnly
-  @param {String} moduleName the module name that the template only component represents, this will be used for debugging purposes
-  @for @ember/component/template-only
-  @category EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
-*/
-export { templateOnlyComponent as default } from '@glimmer/runtime';
+import { templateOnlyComponent as glimmerTemplateOnlyComponent } from '@glimmer/runtime';
+// NOTES:
+//
+// 1. The generic here is for a *signature: a way to hang information for tools
+//    like Glint which can provide typey checking for component templates using
+//    information supplied via this generic. While it may appear useless on this
+//    class definition and extension, it is used by external tools and should
+//    not be removed.
+// 2. SAFETY: this cast is *throwing away* information that is not part of the
+//    public API and replacing it with something which has the same calling
+//    contract, but much less information (since we do not want to expose the
+//    internal APIs like `moduleName` etc.).
+// prettier-ignore
+const templateOnly = glimmerTemplateOnlyComponent;
+export default templateOnly;

package/dist/packages/@ember/debug/index.js

@@ -10,6 +10,8 @@ export { isTesting, setTesting } from './lib/testing';
 export { default as captureRenderTree } from './lib/capture-render-tree';
 // These are the default production build versions:
 const noop = () => {};
+// SAFETY: these casts are just straight-up lies, but the point is that they do
+// not do anything in production builds.
 let assert = noop;
 let info = noop;
 let warn = noop;
@@ -73,39 +75,13 @@ if (DEBUG) {
 @module @ember/debug
 */
 if (DEBUG) {
-  /**
-    Verify that a certain expectation is met, or throw a exception otherwise.
-       This is useful for communicating assumptions in the code to other human
-    readers as well as catching bugs that accidentally violates these
-    expectations.
-       Assertions are removed from production builds, so they can be freely added
-    for documentation and debugging purposes without worries of incuring any
-    performance penalty. However, because of that, they should not be used for
-    checks that could reasonably fail during normal usage. Furthermore, care
-    should be taken to avoid accidentally relying on side-effects produced from
-    evaluating the condition itself, since the code will not run in production.
-       ```javascript
-    import { assert } from '@ember/debug';
-       // Test for truthiness
-    assert('Must pass a string', typeof str === 'string');
-       // Fail unconditionally
-    assert('This code path should never be run');
-    ```
-       @method assert
-    @static
-    @for @ember/debug
-    @param {String} description Describes the expectation. This will become the
-      text of the Error thrown if the assertion fails.
-    @param {any} condition Must be truthy for the assertion to pass. If
-      falsy, an exception will be thrown.
-    @public
-    @since 1.0.0
-  */
-  setDebugFunction('assert', function assert(desc, test) {
+  // eslint-disable-next-line no-inner-declarations
+  function assert(desc, test) {
     if (!test) {
       throw new Error(`Assertion Failed: ${desc}`);
     }
-  });
+  }
+  setDebugFunction('assert', assert);
   /**
     Display a debug notice.
        Calls to this function are not invoked in production builds.

package/dist/packages/@ember/debug/lib/warn.js

@@ -78,6 +78,7 @@ if (DEBUG) {
     }
     assert(missingOptionsDeprecation, Boolean(options));
     assert(missingOptionsIdDeprecation, Boolean(options && options.id));
+    // SAFETY: we checked this by way of the `arguments` check above.
     invoke('warn', message, test, options);
   };
 }

package/dist/packages/@ember/helper/index.js

@@ -1,6 +1,8 @@
 /**
 @module @ember/helper
 */
+import { setHelperManager as glimmerSetHelperManager, helperCapabilities } from '@glimmer/manager';
+import { invokeHelper as glimmerInvokeHelper, hash as glimmerHash, array as glimmerArray, concat as glimmerConcat, get as glimmerGet, fn as glimmerFn } from '@glimmer/runtime';
 /**
   `capabilities` returns a capabilities configuration which can be used to modify
   the behavior of the manager. Manager capabilities _must_ be provided using the
@@ -53,6 +55,7 @@
   @return {Capabilities} The capabilities object instance
   @public
 */
+export const capabilities = helperCapabilities;
 /**
   Sets the helper manager for an object or function.
 
@@ -245,6 +248,7 @@
   @return {object} The definition passed into setHelperManager
   @public
 */
+export const setHelperManager = glimmerSetHelperManager;
 /**
   The `invokeHelper` function can be used to create a helper instance in
   JavaScript.
@@ -277,7 +281,7 @@
     }
   }
   ```
-  ```hbs
+  ```js
   {{this.value}}
   ```
 
@@ -308,5 +312,137 @@
   @returns
   @public
 */
-export { setHelperManager, helperCapabilities as capabilities } from '@glimmer/manager';
-export { invokeHelper, hash, array, concat, get, fn } from '@glimmer/runtime';
+export const invokeHelper = glimmerInvokeHelper;
+// SAFETY: we need to provide interfaces that Glint can declaration-merge with
+// to provide appropriate completions. In each case, the imported item is
+// currently typed only as `object`, and we are replacing it with a similarly
+// low-information interface type: these are empty objects which are simply able
+// to be distinguished so that Glint can provide the relevant extensions.
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/**
+ * Using the `{{hash}}` helper, you can pass objects directly from the template
+ * as an argument to your components.
+ *
+ * ```
+ * import { hash } from '@ember/helper';
+ *
+ * <template>
+ *   {{#each-in (hash givenName='Jen' familyName='Weber') as |key value|}}
+ *     <p>{{key}}: {{value}}</p>
+ *   {{/each-in}}
+ * </template>
+ * ```
+ *
+ * **NOTE:** this example uses the experimental `<template>` feature, which is
+ * the only place you need to import `hash` to use it (it is a built-in when
+ * writing standalone `.hbs` files).
+ */
+export const hash = glimmerHash;
+/**
+ * Using the `{{array}}` helper, you can pass arrays directly from the template
+ * as an argument to your components.
+ *
+ * ```js
+ * import { array } from '@ember/helper';
+ *
+ * <template>
+ *   <ul>
+ *   {{#each (array 'Tom Dale' 'Yehuda Katz' @anotherPerson) as |person|}}
+ *     <li>{{person}}</li>
+ *   {{/each}}
+ *   </ul>
+ * </template>
+ *
+ * **NOTE:** this example uses the experimental `<template>` feature, which is
+ * the only place you need to import `array` to use it (it is a built-in when
+ * writing standalone `.hbs` files).
+ * ```
+ */
+export const array = glimmerArray;
+/**
+ * The `{{concat}}` helper makes it easy to dynamically send a number of
+ * parameters to a component or helper as a single parameter in the format of a
+ * concatenated string.
+ *
+ * For example:
+ *
+ * ```js
+ * import { concat } from '@ember/helper';
+ *
+ * <template>
+ *   {{get @foo (concat "item" @index)}}
+ * </template>
+ * ```
+ *
+ * This will display the result of `@foo.item1` when `index` is `1`, and
+ * `this.foo.item2` when `index` is `2`, etc.
+ *
+ * **NOTE:** this example uses the experimental `<template>` feature, which is
+ * the only place you need to import `concat` to use it (it is a built-in when
+ * writing standalone `.hbs` files).
+ */
+export const concat = glimmerConcat;
+/**
+ * The `{{get}}` helper makes it easy to dynamically look up a property on an
+ * object or an element in an array. The second argument to `{{get}}` can be a
+ * string or a number, depending on the object being accessed.
+ *
+ * To access a property on an object with a string key:
+ *
+ * ```js
+ * import { get } from '@ember/helper';
+ *
+ * <template>
+ *   {{get @someObject "objectKey"}}
+ * </template>
+ * ```
+ *
+ * To access the first element in an array:
+ *
+ * ```js
+ * import { get } from '@ember/helper';
+ *
+ * <template>
+ *   {{get @someArray 0}}
+ * </template>
+ * ```
+ *
+ * To access a property on an object with a dynamic key:
+ *
+ * ```js
+ * import { get } from '@ember/helper';
+ *
+ * <template>
+ *   {{get @address @field}}
+ * </template>
+ * ```
+ *
+ * This will display the result of `@foo.item1` when `index` is `1`, and
+ * `this.foo.item2` when `index` is `2`, etc.
+ *
+ * **NOTE:** this example uses the experimental `<template>` feature, which is
+ * the only place you need to import `concat` to use it (it is a built-in when
+ * writing standalone `.hbs` files).
+ */
+export const get = glimmerGet;
+/**
+ * `{{fn}}` is a helper that receives a function and some arguments, and returns
+ * a new function that combines. This allows you to pass parameters along to
+ * functions in your templates:
+ *
+ * ```js
+ * import { fn } from '@ember/helper';
+ *
+ * function showAlert(message) {
+ *   alert(`The message is: '${message}'`);
+ * }
+ *
+ * <template>
+ *   <button type="button" {{on "click" (fn showAlert "Hello!")}}>
+ *     Click me!
+ *   </button>
+ * </template>
+ * ```
+ */
+export const fn = glimmerFn;
+/* eslint-enable @typescript-eslint/no-empty-interface */

package/dist/packages/@ember/modifier/index.js

@@ -1,3 +1,11 @@
-export { setModifierManager } from '@glimmer/manager';
-export { modifierCapabilities as capabilities } from '@ember/-internals/glimmer';
-export { on } from '@glimmer/runtime';
+import { on as glimmerOn } from '@glimmer/runtime';
+import { setModifierManager as glimmerSetModifierManager } from '@glimmer/manager';
+// SAFETY: at the time of writing, the cast here is from `{}` to `OnModifier`,
+// which makes it strictly safer to use outside this module because it is not
+// usable as "any non-null item", which is what `{}` means, without loss of any
+// information from the type itself.
+export const on = glimmerOn;
+// NOTE: this uses assignment to *require* that the `glimmerSetModifierManager`
+// is legally assignable to this type, i.e. that variance is properly upheld.
+export const setModifierManager = glimmerSetModifierManager;
+export { modifierCapabilities as capabilities } from '@ember/-internals/glimmer';