diff --git a/packages/@ember/-internals/glimmer/lib/helpers/action.ts b/packages/@ember/-internals/glimmer/lib/helpers/action.ts
deleted file mode 100644
index 8f2423972ab..00000000000
--- a/packages/@ember/-internals/glimmer/lib/helpers/action.ts
+++ /dev/null
@@ -1,441 +0,0 @@
-/**
-@module ember
-*/
-import { get } from '@ember/-internals/metal';
-import type { AnyFn } from '@ember/-internals/utility-types';
-import { assert } from '@ember/debug';
-import { flaggedInstrument } from '@ember/instrumentation';
-import { join } from '@ember/runloop';
-import { DEBUG } from '@glimmer/env';
-import type { CapturedArguments } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { createUnboundRef, isInvokableRef, updateRef, valueForRef } from '@glimmer/reference';
-import { internalHelper } from './internal-helper';
-
-export const ACTIONS = new WeakSet();
-
-/**
- The `{{action}}` helper provides a way to pass triggers for behavior (usually
- just a function) between components, and into components from controllers.
-
- ### Passing functions with the action helper
-
- There are three contexts an action helper can be used in. The first two
- contexts to discuss are attribute context, and Handlebars value context.
-
- ```handlebars
- {{! An example of attribute context }}
-
- {{! Examples of Handlebars value context }}
- {{input on-input=(action "save")}}
- {{yield (action "refreshData") andAnotherParam}}
- ```
-
- In these contexts,
- the helper is called a "closure action" helper. Its behavior is simple:
- If passed a function name, read that function off the `actions` property
- of the current context. Once that function is read, or immediately if a function was
- passed, create a closure over that function and any arguments.
- The resulting value of an action helper used this way is simply a function.
-
- For example, in the attribute context:
-
- ```handlebars
- {{! An example of attribute context }}
-
- ```
-
- The resulting template render logic would be:
-
- ```js
- var div = document.createElement('div');
- var actionFunction = (function(context){
- return function() {
- return context.actions.save.apply(context, arguments);
- };
- })(context);
- div.onclick = actionFunction;
- ```
-
- Thus when the div is clicked, the action on that context is called.
- Because the `actionFunction` is just a function, closure actions can be
- passed between components and still execute in the correct context.
-
- Here is an example action handler on a component:
-
- ```app/components/my-component.js
- import Component from '@glimmer/component';
- import { action } from '@ember/object';
-
- export default class extends Component {
- @action
- save() {
- this.model.save();
- }
- }
- ```
-
- Actions are always looked up on the `actions` property of the current context.
- This avoids collisions in the naming of common actions, such as `destroy`.
- Two options can be passed to the `action` helper when it is used in this way.
-
- * `target=someProperty` will look to `someProperty` instead of the current
- context for the `actions` hash. This can be useful when targeting a
- service for actions.
- * `value="target.value"` will read the path `target.value` off the first
- argument to the action when it is called and rewrite the first argument
- to be that value. This is useful when attaching actions to event listeners.
-
- ### Invoking an action
-
- Closure actions curry both their scope and any arguments. When invoked, any
- additional arguments are added to the already curried list.
- Actions are presented in JavaScript as callbacks, and are
- invoked like any other JavaScript function.
-
- For example
-
- ```app/components/update-name.js
- import Component from '@glimmer/component';
- import { action } from '@ember/object';
-
- export default class extends Component {
- @action
- setName(model, name) {
- model.set('name', name);
- }
- }
- ```
-
- ```app/components/update-name.hbs
- {{input on-input=(action (action 'setName' @model) value="target.value")}}
- ```
-
- The first argument (`@model`) was curried over, and the run-time argument (`event`)
- becomes a second argument. Action calls can be nested this way because each simply
- returns a function. Any function can be passed to the `{{action}}` helper, including
- other actions.
-
- Actions invoked with `sendAction` have the same currying behavior as demonstrated
- with `on-input` above. For example:
-
- ```app/components/my-input.js
- import Component from '@glimmer/component';
- import { action } from '@ember/object';
-
- export default class extends Component {
- @action
- setName(model, name) {
- model.set('name', name);
- }
- }
- ```
-
- ```handlebars
-
- ```
-
- or
-
- ```handlebars
- {{my-input submit=(action 'setName' @model)}}
- ```
-
- ```app/components/my-component.js
- import Component from '@ember/component';
-
- export default Component.extend({
- click() {
- // Note that model is not passed, it was curried in the template
- this.submit('bob');
- }
- });
- ```
-
- ### Attaching actions to DOM elements
-
- The third context of the `{{action}}` helper can be called "element space".
- For example:
-
- ```handlebars
- {{! An example of element space }}
-
- ```
-
- Used this way, the `{{action}}` helper provides a useful shortcut for
- registering an HTML element in a template for a single DOM event and
- forwarding that interaction to the template's context (controller or component).
- If the context of a template is a controller, actions used this way will
- bubble to routes when the controller does not implement the specified action.
- Once an action hits a route, it will bubble through the route hierarchy.
-
- ### Event Propagation
-
- `{{action}}` helpers called in element space can control event bubbling. Note
- that the closure style actions cannot.
-
- Events triggered through the action helper will automatically have
- `.preventDefault()` called on them. You do not need to do so in your event
- handlers. If you need to allow event propagation (to handle file inputs for
- example) you can supply the `preventDefault=false` option to the `{{action}}` helper:
-
- ```handlebars
-
-
-
-
- ```
-
- To disable bubbling, pass `bubbles=false` to the helper:
-
- ```handlebars
-
- ```
-
- To disable bubbling with closure style actions you must create your own
- wrapper helper that makes use of `event.stopPropagation()`:
-
- ```handlebars
-
Hello
- ```
-
- ```app/helpers/disable-bubbling.js
- import { helper } from '@ember/component/helper';
-
- export function disableBubbling([action]) {
- return function(event) {
- event.stopPropagation();
- return action(event);
- };
- }
- export default helper(disableBubbling);
- ```
-
- If you need the default handler to trigger you should either register your
- own event handler, or use event methods on your view class. See
- ["Responding to Browser Events"](/ember/release/classes/Component)
- in the documentation for `Component` for more information.
-
- ### Specifying DOM event type
-
- `{{action}}` helpers called in element space can specify an event type.
- By default the `{{action}}` helper registers for DOM `click` events. You can
- supply an `on` option to the helper to specify a different DOM event name:
-
- ```handlebars
-
- click me
-
- ```
-
- See ["Event Names"](/ember/release/classes/Component) for a list of
- acceptable DOM event names.
-
- ### Specifying whitelisted modifier keys
-
- `{{action}}` helpers called in element space can specify modifier keys.
- By default the `{{action}}` helper will ignore click events with pressed modifier
- keys. You can supply an `allowedKeys` option to specify which keys should not be ignored.
-
- ```handlebars
-
- click me
-
- ```
-
- This way the action will fire when clicking with the alt key pressed down.
- Alternatively, supply "any" to the `allowedKeys` option to accept any combination of modifier keys.
-
- ```handlebars
-
- click me with any key pressed
-
- ```
-
- ### Specifying a Target
-
- A `target` option can be provided to the helper to change
- which object will receive the method call. This option must be a path
- to an object, accessible in the current context:
-
- ```app/templates/application.hbs
-
- click me
-
- ```
-
- ```app/controllers/application.js
- import Controller from '@ember/controller';
- import { service } from '@ember/service';
-
- export default class extends Controller {
- @service someService;
- }
- ```
-
- @method action
- @for Ember.Templates.helpers
- @public
-*/
-export default internalHelper((args: CapturedArguments): Reference => {
- let { named, positional } = args;
- // The first two argument slots are reserved.
- // pos[0] is the context (or `this`)
- // pos[1] is the action name or function
- // Anything else is an action argument.
- let [context, action, ...restArgs] = positional;
- assert('hash position arguments', context && action);
-
- let debugKey: string = action.debugLabel!;
-
- let target = 'target' in named ? named['target'] : context;
- let processArgs = makeArgsProcessor(('value' in named && named['value']) || false, restArgs);
-
- let fn: Function;
-
- if (isInvokableRef(action)) {
- fn = makeClosureAction(action, action as MaybeActionHandler, invokeRef, processArgs, debugKey);
- } else {
- fn = makeDynamicClosureAction(
- valueForRef(context) as object,
- // SAFETY: glimmer-vm should expose narrowing utilities for references
- // as is, `target` is still `Reference`.
- // however, we never even tried to narrow `target`, so this is potentially risky code.
- target!,
- // SAFETY: glimmer-vm should expose narrowing utilities for references
- // as is, `action` is still `Reference`
- action,
- processArgs,
- debugKey
- );
- }
-
- ACTIONS.add(fn);
-
- return createUnboundRef(fn, '(result of an `action` helper)');
-});
-
-function NOOP(args: unknown[]) {
- return args;
-}
-
-function makeArgsProcessor(valuePathRef: Reference | false, actionArgsRef: Reference[]) {
- let mergeArgs: ((args: unknown[]) => unknown[]) | undefined;
-
- if (actionArgsRef.length > 0) {
- mergeArgs = (args: unknown[]) => {
- return actionArgsRef.map(valueForRef).concat(args);
- };
- }
-
- let readValue: ((args: unknown[]) => unknown[]) | undefined;
-
- if (valuePathRef) {
- readValue = (args: unknown[]) => {
- let valuePath = valueForRef(valuePathRef);
-
- if (valuePath && args.length > 0) {
- args[0] = get(args[0] as object, valuePath as string);
- }
-
- return args;
- };
- }
-
- if (mergeArgs && readValue) {
- return (args: unknown[]) => {
- return readValue!(mergeArgs!(args));
- };
- } else {
- return mergeArgs || readValue || NOOP;
- }
-}
-
-function makeDynamicClosureAction(
- context: object,
- targetRef: Reference,
- actionRef: Reference,
- processArgs: (args: unknown[]) => unknown[],
- debugKey: string
-) {
- const action = valueForRef(actionRef);
-
- // We don't allow undefined/null values, so this creates a throw-away action to trigger the assertions
- if (DEBUG) {
- makeClosureAction(context, valueForRef(targetRef), action, processArgs, debugKey);
- }
-
- return (...args: any[]) => {
- return makeClosureAction(
- context,
- valueForRef(targetRef),
- action,
- processArgs,
- debugKey
- )(...args);
- };
-}
-
-interface MaybeActionHandler {
- actions?: Record;
-}
-
-function makeClosureAction(
- context: object,
- target: unknown,
- action: unknown | null | undefined | string | Function,
- processArgs: (args: unknown[]) => unknown[],
- debugKey: string
-) {
- let self: object;
- let fn: Function;
-
- assert(
- `Action passed is null or undefined in (action) from ${target}.`,
- action !== undefined && action !== null
- );
-
- if (typeof action === 'string') {
- assert('target must be an object', target !== null && typeof target === 'object');
- self = target;
- let value = (target as { actions?: Record }).actions?.[action];
- assert(`An action named '${action}' was not found in ${target}`, Boolean(value));
- assert(
- `An action named '${action}' was found in ${target}, but is not a function`,
- typeof value === 'function'
- );
- fn = value;
- } else if (typeof action === 'function') {
- self = context;
- fn = action;
- } else {
- assert(
- `An action could not be made for \`${
- debugKey || action
- }\` in ${target}. Please confirm that you are using either a quoted action name (i.e. \`(action '${
- debugKey || 'myAction'
- }')\`) or a function available in ${target}.`,
- false
- );
- }
-
- return (...args: any[]) => {
- let payload = { target: self, args, label: '@glimmer/closure-action' };
- return flaggedInstrument('interaction.ember-action', payload, () => {
- return join(self, fn as AnyFn, ...processArgs(args));
- });
- };
-}
-
-// The code above:
-
-// 1. Finds an action function, usually on the `actions` hash
-// 2. Calls it with the target as the correct `this` context
-
-// Previously, `UPDATE_REFERENCED_VALUE` was a method on the reference itself,
-// so this made a bit more sense. Now, it isn't, and so we need to create a
-// function that can have `this` bound to it when called. This allows us to use
-// the same codepath to call `updateRef` on the reference.
-function invokeRef(this: Reference, value: unknown) {
- updateRef(this, value);
-}
diff --git a/packages/@ember/-internals/glimmer/lib/modifiers/action.ts b/packages/@ember/-internals/glimmer/lib/modifiers/action.ts
deleted file mode 100644
index 249eaeb9436..00000000000
--- a/packages/@ember/-internals/glimmer/lib/modifiers/action.ts
+++ /dev/null
@@ -1,285 +0,0 @@
-import type { InternalOwner } from '@ember/-internals/owner';
-import { uuid } from '@ember/-internals/utils';
-import { ActionManager, EventDispatcher, isSimpleClick } from '@ember/-internals/views';
-import { assert } from '@ember/debug';
-import { flaggedInstrument } from '@ember/instrumentation';
-import { join } from '@ember/runloop';
-import { registerDestructor } from '@glimmer/destroyable';
-import { DEBUG } from '@glimmer/env';
-import type {
- CapturedArguments,
- CapturedNamedArguments,
- CapturedPositionalArguments,
- InternalModifierManager,
-} from '@glimmer/interfaces';
-import { setInternalModifierManager } from '@glimmer/manager';
-import { isInvokableRef, updateRef, valueForRef } from '@glimmer/reference';
-import type { UpdatableTag } from '@glimmer/validator';
-import { createUpdatableTag } from '@glimmer/validator';
-import type { SimpleElement } from '@simple-dom/interface';
-
-const MODIFIERS = ['alt', 'shift', 'meta', 'ctrl'];
-const POINTER_EVENT_TYPE_REGEX = /^click|mouse|touch/;
-
-function isAllowedEvent(event: Event, allowedKeys: any) {
- if (allowedKeys === null || allowedKeys === undefined) {
- if (POINTER_EVENT_TYPE_REGEX.test(event.type)) {
- return isSimpleClick(event);
- } else {
- allowedKeys = '';
- }
- }
-
- if (allowedKeys.indexOf('any') >= 0) {
- return true;
- }
-
- for (let i = 0; i < MODIFIERS.length; i++) {
- if ((event as any)[MODIFIERS[i] + 'Key'] && allowedKeys.indexOf(MODIFIERS[i]) === -1) {
- return false;
- }
- }
-
- return true;
-}
-
-export let ActionHelper = {
- // registeredActions is re-exported for compatibility with older plugins
- // that were using this undocumented API.
- registeredActions: ActionManager.registeredActions,
-
- registerAction(actionState: ActionState) {
- let { actionId } = actionState;
-
- ActionManager.registeredActions[actionId] = actionState;
-
- return actionId;
- },
-
- unregisterAction(actionState: ActionState) {
- let { actionId } = actionState;
-
- delete ActionManager.registeredActions[actionId];
- },
-};
-
-export class ActionState {
- public element: SimpleElement;
- public owner: InternalOwner;
- public actionId: number;
- public actionName: any;
- public actionArgs: any;
- public namedArgs: CapturedNamedArguments;
- public positional: CapturedPositionalArguments;
- public implicitTarget: any;
- public eventName: any;
- public tag = createUpdatableTag();
-
- constructor(
- element: SimpleElement,
- owner: InternalOwner,
- actionId: number,
- actionArgs: any[],
- namedArgs: CapturedNamedArguments,
- positionalArgs: CapturedPositionalArguments
- ) {
- this.element = element;
- this.owner = owner;
- this.actionId = actionId;
- this.actionArgs = actionArgs;
- this.namedArgs = namedArgs;
- this.positional = positionalArgs;
- this.eventName = this.getEventName();
-
- registerDestructor(this, () => ActionHelper.unregisterAction(this));
- }
-
- getEventName() {
- let { on } = this.namedArgs;
-
- return on !== undefined ? valueForRef(on) : 'click';
- }
-
- getActionArgs() {
- let result = new Array(this.actionArgs.length);
-
- for (let i = 0; i < this.actionArgs.length; i++) {
- result[i] = valueForRef(this.actionArgs[i]);
- }
-
- return result;
- }
-
- getTarget(): any {
- let { implicitTarget, namedArgs } = this;
- let { target } = namedArgs;
-
- return target !== undefined ? valueForRef(target) : valueForRef(implicitTarget);
- }
-
- handler(event: Event): boolean {
- let { actionName, namedArgs } = this;
- let { bubbles, preventDefault, allowedKeys } = namedArgs;
-
- let bubblesVal = bubbles !== undefined ? valueForRef(bubbles) : undefined;
- let preventDefaultVal = preventDefault !== undefined ? valueForRef(preventDefault) : undefined;
- let allowedKeysVal = allowedKeys !== undefined ? valueForRef(allowedKeys) : undefined;
-
- let target = this.getTarget();
-
- let shouldBubble = bubblesVal !== false;
-
- if (!isAllowedEvent(event, allowedKeysVal)) {
- return true;
- }
-
- if (preventDefaultVal !== false) {
- event.preventDefault();
- }
-
- if (!shouldBubble) {
- event.stopPropagation();
- }
-
- join(() => {
- let args = this.getActionArgs();
- let payload = {
- args,
- target,
- name: null,
- };
- if (isInvokableRef(actionName)) {
- flaggedInstrument('interaction.ember-action', payload, () => {
- updateRef(actionName, args[0]);
- });
- return;
- }
- if (typeof actionName === 'function') {
- flaggedInstrument('interaction.ember-action', payload, () => {
- actionName.apply(target, args);
- });
- return;
- }
- payload.name = actionName;
- if (target.send) {
- flaggedInstrument('interaction.ember-action', payload, () => {
- target.send.apply(target, [actionName, ...args]);
- });
- } else {
- assert(
- `The action '${actionName}' did not exist on ${target}`,
- typeof target[actionName] === 'function'
- );
- flaggedInstrument('interaction.ember-action', payload, () => {
- target[actionName].apply(target, args);
- });
- }
- });
-
- return shouldBubble;
- }
-}
-
-class ActionModifierManager implements InternalModifierManager {
- create(
- owner: InternalOwner,
- element: SimpleElement,
- _state: object,
- { named, positional }: CapturedArguments
- ): ActionState {
- let actionArgs: any[] = [];
- // The first two arguments are (1) `this` and (2) the action name.
- // Everything else is a param.
- for (let i = 2; i < positional.length; i++) {
- actionArgs.push(positional[i]);
- }
-
- let actionId = uuid();
-
- return new ActionState(element, owner, actionId, actionArgs, named, positional);
- }
-
- getDebugName(): string {
- return 'action';
- }
-
- install(actionState: ActionState): void {
- let { element, actionId, positional } = actionState;
-
- let actionName;
- let actionNameRef: any;
- let implicitTarget;
-
- if (positional.length > 1) {
- implicitTarget = positional[0];
- actionNameRef = positional[1];
-
- if (isInvokableRef(actionNameRef)) {
- actionName = actionNameRef;
- } else {
- actionName = valueForRef(actionNameRef);
-
- if (DEBUG) {
- let actionPath = actionNameRef.debugLabel;
- let actionPathParts = actionPath.split('.');
- let actionLabel = actionPathParts[actionPathParts.length - 1];
-
- assert(
- 'You specified a quoteless path, `' +
- actionPath +
- '`, to the ' +
- '{{action}} helper which did not resolve to an action name (a ' +
- 'string). Perhaps you meant to use a quoted actionName? (e.g. ' +
- '{{action "' +
- actionLabel +
- '"}}).',
- typeof actionName === 'string' || typeof actionName === 'function'
- );
- }
- }
- }
-
- actionState.actionName = actionName;
- actionState.implicitTarget = implicitTarget;
-
- this.ensureEventSetup(actionState);
- ActionHelper.registerAction(actionState);
-
- element.setAttribute('data-ember-action', '');
- element.setAttribute(`data-ember-action-${actionId}`, String(actionId));
- }
-
- update(actionState: ActionState): void {
- let { positional } = actionState;
- let actionNameRef = positional[1];
- assert('Expected at least one positional arg', actionNameRef);
-
- if (!isInvokableRef(actionNameRef)) {
- actionState.actionName = valueForRef(actionNameRef);
- }
-
- let newEventName = actionState.getEventName();
- if (newEventName !== actionState.eventName) {
- this.ensureEventSetup(actionState);
- actionState.eventName = actionState.getEventName();
- }
- }
-
- ensureEventSetup(actionState: ActionState): void {
- let dispatcher = actionState.owner.lookup('event_dispatcher:main');
- assert('Expected dispatcher to be an EventDispatcher', dispatcher instanceof EventDispatcher);
- dispatcher?.setupHandlerForEmberEvent(actionState.eventName);
- }
-
- getTag(actionState: ActionState): UpdatableTag {
- return actionState.tag;
- }
-
- getDestroyable(actionState: ActionState): object {
- return actionState;
- }
-}
-
-const ACTION_MODIFIER_MANAGER = new ActionModifierManager();
-
-export default setInternalModifierManager(ACTION_MODIFIER_MANAGER, {});
diff --git a/packages/@ember/-internals/glimmer/lib/resolver.ts b/packages/@ember/-internals/glimmer/lib/resolver.ts
index 5ad07efc0c4..3c4953a5246 100644
--- a/packages/@ember/-internals/glimmer/lib/resolver.ts
+++ b/packages/@ember/-internals/glimmer/lib/resolver.ts
@@ -37,14 +37,12 @@ import { default as inElementNullCheckHelper } from './helpers/-in-element-null-
import { default as normalizeClassHelper } from './helpers/-normalize-class';
import { default as resolve } from './helpers/-resolve';
import { default as trackArray } from './helpers/-track-array';
-import { default as action } from './helpers/action';
import { default as eachIn } from './helpers/each-in';
import { default as mut } from './helpers/mut';
import { default as readonly } from './helpers/readonly';
import { default as unbound } from './helpers/unbound';
import { default as uniqueId } from './helpers/unique-id';
-import actionModifier from './modifiers/action';
import { mountHelper } from './syntax/mount';
import { outletHelper } from './syntax/outlet';
@@ -109,7 +107,6 @@ function lookupComponentPair(
}
const BUILTIN_KEYWORD_HELPERS: Record = {
- action,
mut,
readonly,
unbound,
@@ -147,12 +144,7 @@ if (DEBUG) {
BUILTIN_HELPERS['-disallow-dynamic-resolution'] = disallowDynamicResolution;
}
-const BUILTIN_KEYWORD_MODIFIERS: Record = {
- action: actionModifier,
-};
-
const BUILTIN_MODIFIERS: Record = {
- ...BUILTIN_KEYWORD_MODIFIERS,
on,
};
diff --git a/packages/@ember/-internals/glimmer/lib/utils/process-args.ts b/packages/@ember/-internals/glimmer/lib/utils/process-args.ts
index 51e79131dc5..27014c8ab11 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/process-args.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/process-args.ts
@@ -4,7 +4,6 @@ import type { Reference } from '@glimmer/reference';
import { isUpdatableRef, updateRef, valueForRef } from '@glimmer/reference';
import { assert } from '@ember/debug';
import { ARGS } from '../component-managers/curly';
-import { ACTIONS } from '../helpers/action';
// ComponentArgs takes EvaluatedNamedArgs and converts them into the
// inputs needed by CurlyComponents (attrs and props, with mutable
@@ -20,9 +19,7 @@ export function processComponentArgs(namedArgs: CapturedNamedArguments) {
assert('expected ref', ref);
let value = valueForRef(ref);
- let isAction = typeof value === 'function' && ACTIONS.has(value);
-
- if (isUpdatableRef(ref) && !isAction) {
+ if (isUpdatableRef(ref)) {
attrs[name] = new MutableCell(ref, value);
} else {
attrs[name] = value;
diff --git a/packages/@ember/-internals/glimmer/tests/integration/application/actions-test.js b/packages/@ember/-internals/glimmer/tests/integration/application/actions-test.js
deleted file mode 100644
index a0d3df9d997..00000000000
--- a/packages/@ember/-internals/glimmer/tests/integration/application/actions-test.js
+++ /dev/null
@@ -1,109 +0,0 @@
-import { moduleFor, ApplicationTestCase, RenderingTestCase, runTask } from 'internal-test-helpers';
-
-import Controller from '@ember/controller';
-import { getDebugFunction, setDebugFunction } from '@ember/debug';
-
-import { Component } from '../../utils/helpers';
-
-const originalDebug = getDebugFunction('debug');
-const noop = function () {};
-
-moduleFor(
- 'Application test: actions',
- class extends ApplicationTestCase {
- constructor() {
- setDebugFunction('debug', noop);
- super(...arguments);
- }
-
- teardown() {
- setDebugFunction('debug', originalDebug);
- }
-
- ['@test actions in top level template application template target application controller'](
- assert
- ) {
- assert.expect(1);
-
- this.add(
- 'controller:application',
- Controller.extend({
- actions: {
- handleIt() {
- assert.ok(true, 'controller received action properly');
- },
- },
- })
- );
-
- this.addTemplate(
- 'application',
- ''
- );
-
- return this.visit('/').then(() => {
- runTask(() => this.$('#handle-it').click());
- });
- }
-
- ['@test actions in nested outlet template target their controller'](assert) {
- assert.expect(1);
-
- this.add(
- 'controller:application',
- Controller.extend({
- actions: {
- handleIt() {
- assert.ok(false, 'application controller should not have received action!');
- },
- },
- })
- );
-
- this.add(
- 'controller:index',
- Controller.extend({
- actions: {
- handleIt() {
- assert.ok(true, 'controller received action properly');
- },
- },
- })
- );
-
- this.addTemplate('index', '');
-
- return this.visit('/').then(() => {
- runTask(() => this.$('#handle-it').click());
- });
- }
- }
-);
-
-moduleFor(
- 'Rendering test: non-interactive actions',
- class extends RenderingTestCase {
- getBootOptions() {
- return { isInteractive: false };
- }
-
- [`@test doesn't attatch actions`](assert) {
- this.registerComponent('foo-bar', {
- ComponentClass: Component.extend({
- actions: {
- fire() {
- assert.ok(false);
- },
- },
- }),
- template: ``,
- });
-
- this.render('{{foo-bar tagName=""}}');
-
- this.assertHTML('');
-
- this.$('button').click();
- }
- }
-);
diff --git a/packages/@ember/-internals/glimmer/tests/integration/components/contextual-components-test.js b/packages/@ember/-internals/glimmer/tests/integration/components/contextual-components-test.js
index 074e4e4a5c2..2b3dc653ee3 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/components/contextual-components-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/components/contextual-components-test.js
@@ -773,10 +773,8 @@ moduleFor(
this.registerComponent('my-action-component', {
ComponentClass: Component.extend({
- actions: {
- changeValue() {
- this.incrementProperty('myProp');
- },
+ changeValue() {
+ this.incrementProperty('myProp');
},
}),
template: strip`
@@ -784,7 +782,7 @@ moduleFor(
{{api.my-nested-component}}
{{/my-component}}
- `,
+ `,
});
this.render('{{my-action-component myProp=this.model.myProp}}', {
@@ -839,13 +837,12 @@ moduleFor(
['@test parameters in a contextual component are mutable when value is a param'](assert) {
// This checks that a `(mut)` is added to parameters and attributes to
// contextual components when it is a param.
-
this.registerComponent('change-button', {
ComponentClass: Component.extend().reopenClass({
positionalParams: ['val'],
}),
template: strip`
-