@glimmer/runtime
Version:
Minimal runtime needed to render Glimmer templates
412 lines (325 loc) • 38 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.OnModifierState = void 0;
var _destroyable = require("@glimmer/destroyable");
var _env = require("@glimmer/env");
var _manager = require("@glimmer/manager");
var _reference = require("@glimmer/reference");
var _runtime = require("@glimmer/runtime");
var _validator = require("@glimmer/validator");
var _util = require("@glimmer/util");
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
var untouchableContext = (0, _util.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.
*/
var SUPPORTS_EVENT_OPTIONS = function () {
try {
var div = document.createElement('div');
var counter = 0;
div.addEventListener('click', function () {
return counter++;
}, {
once: true
});
var 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;
}
}();
var OnModifierState = /*#__PURE__*/function () {
function OnModifierState(element, args) {
this.tag = (0, _validator.createUpdatableTag)();
this.shouldUpdate = true;
this.element = element;
this.args = args;
}
var _proto = OnModifierState.prototype;
_proto.updateFromArgs = function updateFromArgs() {
var args = this.args;
var _reifyNamed = (0, _runtime.reifyNamed)(args.named),
once = _reifyNamed.once,
passive = _reifyNamed.passive,
capture = _reifyNamed.capture;
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;
}
var 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: once,
passive: passive,
capture: capture
};
} else {
this.options = undefined;
}
if (_env.DEBUG && (args.positional[0] === undefined || typeof (0, _reference.valueForRef)(args.positional[0]) !== 'string')) {
throw new Error('You must pass a valid DOM event name as the first argument to the `on` modifier');
}
var eventName = (0, _reference.valueForRef)(args.positional[0]);
if (eventName !== this.eventName) {
this.eventName = eventName;
this.shouldUpdate = true;
}
var userProvidedCallbackReference = args.positional[1];
if (_env.DEBUG) {
if (args.positional[1] === undefined) {
throw new Error("You must pass a function as the second argument to the `on` modifier.");
}
var value = (0, _reference.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);
}
}
var userProvidedCallback = (0, _reference.valueForRef)(userProvidedCallbackReference);
if (userProvidedCallback !== this.userProvidedCallback) {
this.userProvidedCallback = userProvidedCallback;
this.shouldUpdate = true;
}
if (_env.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.");
}
var needsCustomCallback = SUPPORTS_EVENT_OPTIONS === false && once ||
/* needs manual once implementation */
_env.DEBUG && passive;
/* needs passive enforcement */
if (this.shouldUpdate) {
if (needsCustomCallback) {
var callback = this.callback = function (event) {
if (_env.DEBUG && passive) {
event.preventDefault = function () {
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 (_env.DEBUG) {
// prevent the callback from being bound to the element
this.callback = userProvidedCallback.bind(untouchableContext);
} else {
this.callback = userProvidedCallback;
}
}
};
return OnModifierState;
}();
exports.OnModifierState = OnModifierState;
var adds = 0;
var 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
*/
var OnModifierManager = /*#__PURE__*/function () {
function OnModifierManager() {
this.SUPPORTS_EVENT_OPTIONS = SUPPORTS_EVENT_OPTIONS;
}
var _proto2 = OnModifierManager.prototype;
_proto2.getDebugName = function getDebugName() {
return 'on';
};
_proto2.create = function create(_owner, element, _state, args) {
return new OnModifierState(element, args);
};
_proto2.getTag = function getTag(state) {
if (state === null) {
return null;
}
return state.tag;
};
_proto2.install = function install(state) {
if (state === null) {
return;
}
state.updateFromArgs();
var element = state.element,
eventName = state.eventName,
callback = state.callback,
options = state.options;
addEventListener(element, eventName, callback, options);
(0, _destroyable.registerDestructor)(state, function () {
return removeEventListener(element, eventName, callback, options);
});
state.shouldUpdate = false;
};
_proto2.update = function update(state) {
if (state === null) {
return;
} // stash prior state for el.removeEventListener
var element = state.element,
eventName = state.eventName,
callback = state.callback,
options = state.options;
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;
};
_proto2.getDestroyable = function getDestroyable(state) {
return state;
};
_createClass(OnModifierManager, [{
key: "counters",
get: function get() {
return {
adds: adds,
removes: removes
};
}
}]);
return OnModifierManager;
}();
var _default = (0, _manager.setInternalModifierManager)(new OnModifierManager(), {});
exports.default = _default;
//# 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":""}