@glimmer/runtime
Version:
Minimal runtime needed to render Glimmer templates
371 lines (300 loc) • 36.3 kB
JavaScript
import { registerDestructor } from '@glimmer/destroyable';
import { DEBUG } from '@glimmer/env';
import { setInternalModifierManager } from '@glimmer/manager';
import { valueForRef } from '@glimmer/reference';
import { reifyNamed } from '@glimmer/runtime';
import { createUpdatableTag } from '@glimmer/validator';
import { buildUntouchableThis } from '@glimmer/util';
const untouchableContext = buildUntouchableThis('`on` modifier');
/*
Internet Explorer 11 does not support `once` and also does not support
passing `eventOptions`. In some situations it then throws a weird script
error, like:
```
Could not complete the operation due to error 80020101
```
This flag determines, whether `{ once: true }` and thus also event options in
general are supported.
*/
const SUPPORTS_EVENT_OPTIONS = (() => {
try {
const div = document.createElement('div');
let counter = 0;
div.addEventListener('click', () => counter++, {
once: true
});
let event;
if (typeof Event === 'function') {
event = new Event('click');
} else {
event = document.createEvent('Event');
event.initEvent('click', true, true);
}
div.dispatchEvent(event);
div.dispatchEvent(event);
return counter === 1;
} catch (error) {
return false;
}
})();
export class OnModifierState {
constructor(element, args) {
this.tag = createUpdatableTag();
this.shouldUpdate = true;
this.element = element;
this.args = args;
}
updateFromArgs() {
let {
args
} = this;
let {
once,
passive,
capture
} = reifyNamed(args.named);
if (once !== this.once) {
this.once = once;
this.shouldUpdate = true;
}
if (passive !== this.passive) {
this.passive = passive;
this.shouldUpdate = true;
}
if (capture !== this.capture) {
this.capture = capture;
this.shouldUpdate = true;
}
let options; // we want to handle both `true` and `false` because both have a meaning:
// https://bugs.chromium.org/p/chromium/issues/detail?id=770208
if (once !== undefined || passive !== undefined || capture !== undefined) {
options = this.options = {
once,
passive,
capture
};
} else {
this.options = undefined;
}
if (DEBUG && (args.positional[0] === undefined || typeof valueForRef(args.positional[0]) !== 'string')) {
throw new Error('You must pass a valid DOM event name as the first argument to the `on` modifier');
}
let eventName = valueForRef(args.positional[0]);
if (eventName !== this.eventName) {
this.eventName = eventName;
this.shouldUpdate = true;
}
let userProvidedCallbackReference = args.positional[1];
if (DEBUG) {
if (args.positional[1] === undefined) {
throw new Error(`You must pass a function as the second argument to the \`on\` modifier.`);
}
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}`);
}
}
let userProvidedCallback = valueForRef(userProvidedCallbackReference);
if (userProvidedCallback !== this.userProvidedCallback) {
this.userProvidedCallback = userProvidedCallback;
this.shouldUpdate = true;
}
if (DEBUG && args.positional.length !== 2) {
throw new Error(`You can only pass two positional arguments (event name and callback) to the \`on\` modifier, but you provided ${args.positional.length}. Consider using the \`fn\` helper to provide additional arguments to the \`on\` callback.`);
}
let needsCustomCallback = SUPPORTS_EVENT_OPTIONS === false && once ||
/* needs manual once implementation */
DEBUG && passive;
/* needs passive enforcement */
if (this.shouldUpdate) {
if (needsCustomCallback) {
let callback = this.callback = function (event) {
if (DEBUG && passive) {
event.preventDefault = () => {
throw new Error(`You marked this listener as 'passive', meaning that you must not call 'event.preventDefault()': \n\n${userProvidedCallback}`);
};
}
if (!SUPPORTS_EVENT_OPTIONS && once) {
removeEventListener(this, eventName, callback, options);
}
return userProvidedCallback.call(untouchableContext, event);
};
} else if (DEBUG) {
// prevent the callback from being bound to the element
this.callback = userProvidedCallback.bind(untouchableContext);
} else {
this.callback = userProvidedCallback;
}
}
}
}
let adds = 0;
let removes = 0;
function removeEventListener(element, eventName, callback, options) {
removes++;
if (SUPPORTS_EVENT_OPTIONS) {
// when options are supported, use them across the board
element.removeEventListener(eventName, callback, options);
} else if (options !== undefined && options.capture) {
// used only in the following case:
//
// `{ once: true | false, passive: true | false, capture: true }
//
// `once` is handled via a custom callback that removes after first
// invocation so we only care about capture here as a boolean
element.removeEventListener(eventName, callback, true);
} else {
// used only in the following cases:
//
// * where there is no options
// * `{ once: true | false, passive: true | false, capture: false }
element.removeEventListener(eventName, callback);
}
}
function addEventListener(element, eventName, callback, options) {
adds++;
if (SUPPORTS_EVENT_OPTIONS) {
// when options are supported, use them across the board
element.addEventListener(eventName, callback, options);
} else if (options !== undefined && options.capture) {
// used only in the following case:
//
// `{ once: true | false, passive: true | false, capture: true }
//
// `once` is handled via a custom callback that removes after first
// invocation so we only care about capture here as a boolean
element.addEventListener(eventName, callback, true);
} else {
// used only in the following cases:
//
// * where there is no options
// * `{ once: true | false, passive: true | false, capture: false }
element.addEventListener(eventName, callback);
}
}
/**
The `{{on}}` modifier lets you easily add event listeners (it uses
[EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
internally).
For example, if you'd like to run a function on your component when a `<button>`
in the components template is clicked you might do something like:
```app/components/like-post.hbs
<button {{on 'click' this.saveLike}}>Like this post!</button>
```
```app/components/like-post.js
import Component from '@glimmer/component';
import { action } from '@ember/object';
export default class LikePostComponent extends Component {
saveLike = () => {
// someone likes your post!
// better send a request off to your server...
}
}
```
### Arguments
`{{on}}` accepts two positional arguments, and a few named arguments.
The positional arguments are:
- `event` -- the name to use when calling `addEventListener`
- `callback` -- the function to be passed to `addEventListener`
The named arguments are:
- capture -- a `true` value indicates that events of this type will be dispatched
to the registered listener before being dispatched to any EventTarget beneath it
in the DOM tree.
- once -- indicates that the listener should be invoked at most once after being
added. If true, the listener would be automatically removed when invoked.
- passive -- if `true`, indicates that the function specified by listener will never
call preventDefault(). If a passive listener does call preventDefault(), the user
agent will do nothing other than generate a console warning. See
[Improving scrolling performance with passive listeners](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Improving_scrolling_performance_with_passive_listeners)
to learn more.
The callback function passed to `{{on}}` will receive any arguments that are passed
to the event handler. Most commonly this would be the `event` itself.
If you would like to pass additional arguments to the function you should use
the `{{fn}}` helper.
For example, in our example case above if you'd like to pass in the post that
was being liked when the button is clicked you could do something like:
```app/components/like-post.hbs
<button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>
```
In this case, the `saveLike` function will receive two arguments: the click event
and the value of `@post`.
### Function Context
In the example above, we used an arrow function to ensure that `likePost` is
properly bound to the `items-list`, but let's explore what happens if we
left out the arrow function:
```app/components/like-post.js
import Component from '@glimmer/component';
export default class LikePostComponent extends Component {
saveLike() {
// ...snip...
}
}
```
In this example, when the button is clicked `saveLike` will be invoked,
it will **not** have access to the component instance. In other
words, it will have no `this` context, so please make sure your functions
are bound (via an arrow function or other means) before passing into `on`!
@method on
@public
*/
class OnModifierManager {
constructor() {
this.SUPPORTS_EVENT_OPTIONS = SUPPORTS_EVENT_OPTIONS;
}
getDebugName() {
return 'on';
}
get counters() {
return {
adds,
removes
};
}
create(_owner, element, _state, args) {
return new OnModifierState(element, args);
}
getTag(state) {
if (state === null) {
return null;
}
return state.tag;
}
install(state) {
if (state === null) {
return;
}
state.updateFromArgs();
let {
element,
eventName,
callback,
options
} = state;
addEventListener(element, eventName, callback, options);
registerDestructor(state, () => removeEventListener(element, eventName, callback, options));
state.shouldUpdate = false;
}
update(state) {
if (state === null) {
return;
} // stash prior state for el.removeEventListener
let {
element,
eventName,
callback,
options
} = state;
state.updateFromArgs();
if (!state.shouldUpdate) {
return;
} // use prior state values for removal
removeEventListener(element, eventName, callback, options); // read updated values from the state object
addEventListener(state.element, state.eventName, state.callback, state.options);
state.shouldUpdate = false;
}
getDestroyable(state) {
return state;
}
}
export default setInternalModifierManager(new OnModifierManager(), {});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../packages/@glimmer/runtime/lib/modifiers/on.ts"],"names":[],"mappings":"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","sourcesContent":["import { registerDestructor } from '@glimmer/destroyable';\nimport { DEBUG } from '@glimmer/env';\nimport { CapturedArguments, InternalModifierManager, Owner } from '@glimmer/interfaces';\nimport { setInternalModifierManager } from '@glimmer/manager';\nimport { valueForRef } from '@glimmer/reference';\nimport { reifyNamed } from '@glimmer/runtime';\nimport { createUpdatableTag, UpdatableTag } from '@glimmer/validator';\nimport { SimpleElement } from '@simple-dom/interface';\nimport { buildUntouchableThis } from '@glimmer/util';\n\nconst untouchableContext = buildUntouchableThis('`on` modifier');\n\n/*\n  Internet Explorer 11 does not support `once` and also does not support\n  passing `eventOptions`. In some situations it then throws a weird script\n  error, like:\n\n  ```\n  Could not complete the operation due to error 80020101\n  ```\n\n  This flag determines, whether `{ once: true }` and thus also event options in\n  general are supported.\n*/\nconst SUPPORTS_EVENT_OPTIONS = (() => {\n  try {\n    const div = document.createElement('div');\n    let counter = 0;\n    div.addEventListener('click', () => counter++, { once: true });\n\n    let event;\n    if (typeof Event === 'function') {\n      event = new Event('click');\n    } else {\n      event = document.createEvent('Event');\n      event.initEvent('click', true, true);\n    }\n\n    div.dispatchEvent(event);\n    div.dispatchEvent(event);\n\n    return counter === 1;\n  } catch (error) {\n    return false;\n  }\n})();\n\nexport class OnModifierState {\n  public tag = createUpdatableTag();\n  public element: Element;\n  public args: CapturedArguments;\n  public eventName!: string;\n  public callback!: EventListener;\n  private userProvidedCallback!: EventListener;\n  public once?: boolean;\n  public passive?: boolean;\n  public capture?: boolean;\n  public options?: AddEventListenerOptions;\n  public shouldUpdate = true;\n\n  constructor(element: Element, args: CapturedArguments) {\n    this.element = element;\n    this.args = args;\n  }\n\n  updateFromArgs(): void {\n    let { args } = this;\n\n    let { once, passive, capture }: AddEventListenerOptions = reifyNamed(args.named);\n    if (once !== this.once) {\n      this.once = once;\n      this.shouldUpdate = true;\n    }\n\n    if (passive !== this.passive) {\n      this.passive = passive;\n      this.shouldUpdate = true;\n    }\n\n    if (capture !== this.capture) {\n      this.capture = capture;\n      this.shouldUpdate = true;\n    }\n\n    let options: AddEventListenerOptions;\n    // we want to handle both `true` and `false` because both have a meaning:\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=770208\n    if (once !== undefined || passive !== undefined || capture !== undefined) {\n      options = this.options = { once, passive, capture };\n    } else {\n      this.options = undefined;\n    }\n\n    if (\n      DEBUG &&\n      (args.positional[0] === undefined || typeof valueForRef(args.positional[0]) !== 'string')\n    ) {\n      throw new Error(\n        'You must pass a valid DOM event name as the first argument to the `on` modifier'\n      );\n    }\n\n    let eventName = valueForRef(args.positional[0]) as string;\n    if (eventName !== this.eventName) {\n      this.eventName = eventName;\n      this.shouldUpdate = true;\n    }\n\n    let userProvidedCallbackReference = args.positional[1];\n\n    if (DEBUG) {\n      if (args.positional[1] === undefined) {\n        throw new Error(`You must pass a function as the second argument to the \\`on\\` modifier.`);\n      }\n\n      let value = valueForRef(userProvidedCallbackReference);\n\n      if (typeof value !== 'function') {\n        throw new Error(\n          `You must pass a function as the second argument to the \\`on\\` modifier; you passed ${\n            value === null ? 'null' : typeof value\n          }. While rendering:\\n\\n${userProvidedCallbackReference.debugLabel}`\n        );\n      }\n    }\n\n    let userProvidedCallback = valueForRef(userProvidedCallbackReference) as EventListener;\n    if (userProvidedCallback !== this.userProvidedCallback) {\n      this.userProvidedCallback = userProvidedCallback;\n      this.shouldUpdate = true;\n    }\n\n    if (DEBUG && args.positional.length !== 2) {\n      throw new Error(\n        `You can only pass two positional arguments (event name and callback) to the \\`on\\` modifier, but you provided ${args.positional.length}. Consider using the \\`fn\\` helper to provide additional arguments to the \\`on\\` callback.`\n      );\n    }\n\n    let needsCustomCallback =\n      (SUPPORTS_EVENT_OPTIONS === false && once) /* needs manual once implementation */ ||\n      (DEBUG && passive); /* needs passive enforcement */\n\n    if (this.shouldUpdate) {\n      if (needsCustomCallback) {\n        let callback = (this.callback = function (this: Element, event) {\n          if (DEBUG && passive) {\n            event.preventDefault = () => {\n              throw new Error(\n                `You marked this listener as 'passive', meaning that you must not call 'event.preventDefault()': \\n\\n${userProvidedCallback}`\n              );\n            };\n          }\n\n          if (!SUPPORTS_EVENT_OPTIONS && once) {\n            removeEventListener(this, eventName, callback, options);\n          }\n          return userProvidedCallback.call(untouchableContext, event);\n        });\n      } else if (DEBUG) {\n        // prevent the callback from being bound to the element\n        this.callback = userProvidedCallback.bind(untouchableContext);\n      } else {\n        this.callback = userProvidedCallback;\n      }\n    }\n  }\n}\n\nlet adds = 0;\nlet removes = 0;\n\nfunction removeEventListener(\n  element: Element,\n  eventName: string,\n  callback: EventListener,\n  options?: AddEventListenerOptions\n): void {\n  removes++;\n\n  if (SUPPORTS_EVENT_OPTIONS) {\n    // when options are supported, use them across the board\n    element.removeEventListener(eventName, callback, options);\n  } else if (options !== undefined && options.capture) {\n    // used only in the following case:\n    //\n    // `{ once: true | false, passive: true | false, capture: true }\n    //\n    // `once` is handled via a custom callback that removes after first\n    // invocation so we only care about capture here as a boolean\n    element.removeEventListener(eventName, callback, true);\n  } else {\n    // used only in the following cases:\n    //\n    // * where there is no options\n    // * `{ once: true | false, passive: true | false, capture: false }\n    element.removeEventListener(eventName, callback);\n  }\n}\n\nfunction addEventListener(\n  element: Element,\n  eventName: string,\n  callback: EventListener,\n  options?: AddEventListenerOptions\n): void {\n  adds++;\n\n  if (SUPPORTS_EVENT_OPTIONS) {\n    // when options are supported, use them across the board\n    element.addEventListener(eventName, callback, options);\n  } else if (options !== undefined && options.capture) {\n    // used only in the following case:\n    //\n    // `{ once: true | false, passive: true | false, capture: true }\n    //\n    // `once` is handled via a custom callback that removes after first\n    // invocation so we only care about capture here as a boolean\n    element.addEventListener(eventName, callback, true);\n  } else {\n    // used only in the following cases:\n    //\n    // * where there is no options\n    // * `{ once: true | false, passive: true | false, capture: false }\n    element.addEventListener(eventName, callback);\n  }\n}\n\n/**\n  The `{{on}}` modifier lets you easily add event listeners (it uses\n  [EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)\n  internally).\n\n  For example, if you'd like to run a function on your component when a `<button>`\n  in the components template is clicked you might do something like:\n\n  ```app/components/like-post.hbs\n  <button {{on 'click' this.saveLike}}>Like this post!</button>\n  ```\n\n  ```app/components/like-post.js\n  import Component from '@glimmer/component';\n  import { action } from '@ember/object';\n\n  export default class LikePostComponent extends Component {\n    saveLike = () => {\n      // someone likes your post!\n      // better send a request off to your server...\n    }\n  }\n  ```\n\n  ### Arguments\n\n  `{{on}}` accepts two positional arguments, and a few named arguments.\n\n  The positional arguments are:\n\n  - `event` -- the name to use when calling `addEventListener`\n  - `callback` -- the function to be passed to `addEventListener`\n\n  The named arguments are:\n\n  - capture -- a `true` value indicates that events of this type will be dispatched\n    to the registered listener before being dispatched to any EventTarget beneath it\n    in the DOM tree.\n  - once -- indicates that the listener should be invoked at most once after being\n    added. If true, the listener would be automatically removed when invoked.\n  - passive -- if `true`, indicates that the function specified by listener will never\n    call preventDefault(). If a passive listener does call preventDefault(), the user\n    agent will do nothing other than generate a console warning. See\n    [Improving scrolling performance with passive listeners](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Improving_scrolling_performance_with_passive_listeners)\n    to learn more.\n\n  The callback function passed to `{{on}}` will receive any arguments that are passed\n  to the event handler. Most commonly this would be the `event` itself.\n\n  If you would like to pass additional arguments to the function you should use\n  the `{{fn}}` helper.\n\n  For example, in our example case above if you'd like to pass in the post that\n  was being liked when the button is clicked you could do something like:\n\n  ```app/components/like-post.hbs\n  <button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>\n  ```\n\n  In this case, the `saveLike` function will receive two arguments: the click event\n  and the value of `@post`.\n\n  ### Function Context\n\n  In the example above, we used an arrow function to ensure that `likePost` is\n  properly bound to the `items-list`, but let's explore what happens if we\n  left out the arrow function:\n\n  ```app/components/like-post.js\n  import Component from '@glimmer/component';\n\n  export default class LikePostComponent extends Component {\n    saveLike() {\n      // ...snip...\n    }\n  }\n  ```\n\n  In this example, when the button is clicked `saveLike` will be invoked,\n  it will **not** have access to the component instance. In other\n  words, it will have no `this` context, so please make sure your functions\n  are bound (via an arrow function or other means) before passing into `on`!\n\n  @method on\n  @public\n*/\nclass OnModifierManager implements InternalModifierManager<OnModifierState | null, object> {\n  public SUPPORTS_EVENT_OPTIONS: boolean = SUPPORTS_EVENT_OPTIONS;\n\n  getDebugName(): string {\n    return 'on';\n  }\n\n  get counters(): { adds: number; removes: number } {\n    return { adds, removes };\n  }\n\n  create(\n    _owner: Owner,\n    element: SimpleElement | Element,\n    _state: object,\n    args: CapturedArguments\n  ): OnModifierState | null {\n    return new OnModifierState(element as Element, args);\n  }\n\n  getTag(state: OnModifierState | null): UpdatableTag | null {\n    if (state === null) {\n      return null;\n    }\n\n    return state.tag;\n  }\n\n  install(state: OnModifierState | null): void {\n    if (state === null) {\n      return;\n    }\n\n    state.updateFromArgs();\n\n    let { element, eventName, callback, options } = state;\n\n    addEventListener(element, eventName, callback, options);\n\n    registerDestructor(state, () => removeEventListener(element, eventName, callback, options));\n\n    state.shouldUpdate = false;\n  }\n\n  update(state: OnModifierState | null): void {\n    if (state === null) {\n      return;\n    }\n\n    // stash prior state for el.removeEventListener\n    let { element, eventName, callback, options } = state;\n\n    state.updateFromArgs();\n\n    if (!state.shouldUpdate) {\n      return;\n    }\n\n    // use prior state values for removal\n    removeEventListener(element, eventName, callback, options);\n\n    // read updated values from the state object\n    addEventListener(state.element, state.eventName, state.callback, state.options);\n\n    state.shouldUpdate = false;\n  }\n\n  getDestroyable(state: OnModifierState | null): OnModifierState | null {\n    return state;\n  }\n}\n\nexport default setInternalModifierManager(new OnModifierManager(), {});\n"],"sourceRoot":""}