@glimmer/component
Version:
Glimmer component library
183 lines (171 loc) • 19.8 kB
JavaScript
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; }
import { DEBUG } from '@glimmer/env';
import { setOwner } from './owner';
import { isDestroying, isDestroyed } from './destroyables'; // SAFETY: this only holds because we *only* acces this when `DEBUG` is `true`.
// There is not a great way to connect that data in TS at present.
export var ARGS_SET;
if (DEBUG) {
ARGS_SET = new WeakMap();
}
/**
* The `Component` class defines an encapsulated UI element that is rendered to
* the DOM. A component is made up of a template and, optionally, this component
* object.
*
* ## Defining a Component
*
* To define a component, subclass `Component` and add your own properties,
* methods and lifecycle hooks:
*
* ```ts
* import Component from '@glimmer/component';
*
* export default class extends Component {
* }
* ```
*
* ## Lifecycle Hooks
*
* Lifecycle hooks allow you to respond to changes to a component, such as when
* it gets created, rendered, updated or destroyed. To add a lifecycle hook to a
* component, implement the hook as a method on your component subclass.
*
* For example, to be notified when Glimmer has rendered your component so you
* can attach a legacy jQuery plugin, implement the `didInsertElement()` method:
*
* ```ts
* import Component from '@glimmer/component';
*
* export default class extends Component {
* didInsertElement() {
* $(this.element).pickadate();
* }
* }
* ```
*
* ## Data for Templates
*
* `Component`s have two different kinds of data, or state, that can be
* displayed in templates:
*
* 1. Arguments
* 2. Properties
*
* Arguments are data that is passed in to a component from its parent
* component. For example, if I have a `UserGreeting` component, I can pass it
* a name and greeting to use:
*
* ```hbs
* <UserGreeting @name="Ricardo" @greeting="Olá" />
* ```
*
* Inside my `UserGreeting` template, I can access the `@name` and `@greeting`
* arguments that I've been given:
*
* ```hbs
* {{@greeting}}, {{@name}}!
* ```
*
* Arguments are also available inside my component:
*
* ```ts
* console.log(this.args.greeting); // prints "Olá"
* ```
*
* Properties, on the other hand, are internal to the component and declared in
* the class. You can use properties to store data that you want to show in the
* template, or pass to another component as an argument.
*
* ```ts
* import Component from '@glimmer/component';
*
* export default class extends Component {
* user = {
* name: 'Robbie'
* }
* }
* ```
*
* In the above example, we've defined a component with a `user` property that
* contains an object with its own `name` property.
*
* We can render that property in our template:
*
* ```hbs
* Hello, {{user.name}}!
* ```
*
* We can also take that property and pass it as an argument to the
* `UserGreeting` component we defined above:
*
* ```hbs
* <UserGreeting @greeting="Hello" @name={{user.name}} />
* ```
*
* ## Arguments vs. Properties
*
* Remember, arguments are data that was given to your component by its parent
* component, and properties are data your component has defined for itself.
*
* You can tell the difference between arguments and properties in templates
* because arguments always start with an `@` sign (think "A is for arguments"):
*
* ```hbs
* {{@firstName}}
* ```
*
* We know that `@firstName` came from the parent component, not the current
* component, because it starts with `@` and is therefore an argument.
*
* On the other hand, if we see:
*
* ```hbs
* {{name}}
* ```
*
* We know that `name` is a property on the component. If we want to know where
* the data is coming from, we can go look at our component class to find out.
*
* Inside the component itself, arguments always show up inside the component's
* `args` property. For example, if `{{@firstName}}` is `Tom` in the template,
* inside the component `this.args.firstName` would also be `Tom`.
*/
var BaseComponent =
/*#__PURE__*/
function () {
/**
* Constructs a new component and assigns itself the passed properties. You
* should not construct new components yourself. Instead, Glimmer will
* instantiate new components automatically as it renders.
*
* @param owner
* @param args
*/
function BaseComponent(owner, args) {
if (DEBUG && !(owner !== null && typeof owner === 'object' && ARGS_SET.has(args))) {
throw new Error("You must pass both the owner and args to super() in your component: " + this.constructor.name + ". You can pass them directly, or use ...arguments to pass all arguments through.");
}
this.args = args;
setOwner(this, owner);
}
var _proto = BaseComponent.prototype;
/**
* Called before the component has been removed from the DOM.
*/
_proto.willDestroy = function willDestroy() {};
_createClass(BaseComponent, [{
key: "isDestroying",
get: function get() {
return isDestroying(this);
}
}, {
key: "isDestroyed",
get: function get() {
return isDestroyed(this);
}
}]);
return BaseComponent;
}();
export { BaseComponent as default };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../packages/@glimmer/component/addon/-private/component.ts"],"names":[],"mappings":";;;;AAAA,SAAS,KAAT,QAAsB,cAAtB;AACA,SAAS,QAAT,QAAyB,SAAzB;AACA,SAAS,YAAT,EAAuB,WAAvB,QAA0C,gBAA1C,C,CAWA;AACA;;AACA,OAAO,IAAI,QAAJ;;AAEP,IAAI,KAAJ,EAAW;AACT,EAAA,QAAQ,GAAG,IAAI,OAAJ,EAAX;AACD;AA2ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2HqB,a;;;AACnB;;;;;;;;AAQA,yBAAY,KAAZ,EAA4B,IAA5B,EAAyC;AACvC,QAAI,KAAK,IAAI,EAAE,KAAK,KAAK,IAAV,IAAkB,OAAO,KAAP,KAAiB,QAAnC,IAA+C,QAAQ,CAAC,GAAT,CAAa,IAAb,CAAjD,CAAb,EAAmF;AACjF,YAAM,IAAI,KAAJ,0EAEF,KAAK,WAAL,CAAiB,IAFf,sFAAN;AAKD;;AAED,SAAK,IAAL,GAAY,IAAZ;AACA,IAAA,QAAQ,CAAC,IAAD,EAAO,KAAP,CAAR;AACD;;;;AAoCD;;;SAGA,W,GAAA,uBAAW,CAAW,C;;;;wBAXN;AACd,aAAO,YAAY,CAAC,IAAD,CAAnB;AACD;;;wBAEc;AACb,aAAO,WAAW,CAAC,IAAD,CAAlB;AACD;;;;;;SAtDkB,a","sourcesContent":["import { DEBUG } from '@glimmer/env';\nimport { setOwner } from './owner';\nimport { isDestroying, isDestroyed } from './destroyables';\n\n// This provides a type-safe `WeakMap`: the getter and setter link the key to a\n// specific value. This is how `WeakMap`s actually behave, but the TS type\n// system does not (yet!) have a good way to capture that for types like\n// `WeakMap` where the type is generic over another generic type (here, `Args`).\ninterface ArgsSetMap extends WeakMap<Args<unknown>, boolean> {\n  get<S>(key: Args<S>): boolean | undefined;\n  set<S>(key: Args<S>, value: boolean): this;\n}\n\n// SAFETY: this only holds because we *only* acces this when `DEBUG` is `true`.\n// There is not a great way to connect that data in TS at present.\nexport let ARGS_SET: ArgsSetMap;\n\nif (DEBUG) {\n  ARGS_SET = new WeakMap() as ArgsSetMap;\n}\n\n// --- Type utilities for component signatures --- //\n// Type-only \"symbol\" to use with `EmptyObject` below, so that it is *not*\n// equivalent to an empty interface.\ndeclare const Empty: unique symbol;\n\n/**\n * This provides us a way to have a \"fallback\" which represents an empty object,\n * without the downsides of how TS treats `{}`. Specifically: this will\n * correctly leverage \"excess property checking\" so that, given a component\n * which has no named args, if someone invokes it with any named args, they will\n * get a type error.\n *\n * @internal This is exported so declaration emit works (if it were not emitted,\n *   declarations which fall back to it would not work). It is *not* intended for\n *   public usage, and the specific mechanics it uses may change at any time.\n *   The location of this export *is* part of the public API, because moving it\n *   will break existing declarations, but is not legal for end users to import\n *   themselves, so ***DO NOT RELY ON IT***.\n */\nexport type EmptyObject = { [Empty]?: true };\n\ntype GetOrElse<Obj, K extends PropertyKey, Fallback> = Obj extends { [Key in K]: infer U }\n  ? U\n  : Fallback;\n\n/** Given a signature `S`, get back the `Args` type. */\ntype ArgsFor<S> = S extends { Args: infer Args }\n  ? Args extends { Named?: object; Positional?: unknown[] } // Are they longhand already?\n    ? {\n        Named: GetOrElse<S['Args'], 'Named', EmptyObject>;\n        Positional: GetOrElse<S['Args'], 'Positional', []>;\n      }\n    : { Named: S['Args']; Positional: [] }\n  : { Named: EmptyObject; Positional: [] };\n\ntype _ExpandSignature<T> = {\n  Element: GetOrElse<T, 'Element', null>;\n  Args: keyof T extends 'Args' | 'Element' | 'Blocks' // Is this a `Signature`?\n    ? ArgsFor<T> // Then use `Signature` args\n    : { Named: T; Positional: [] }; // Otherwise fall back to classic `Args`.\n  Blocks: T extends { Blocks: infer Blocks }\n    ? {\n        [Block in keyof Blocks]: Blocks[Block] extends unknown[]\n          ? { Params: { Positional: Blocks[Block] } }\n          : Blocks[Block];\n      }\n    : EmptyObject;\n};\n\n/**\n * Given any allowed shorthand form of a signature, desugars it to its full\n * expanded type.\n *\n * @internal This is only exported so we can avoid duplicating it in\n *   [Glint](https://github.com/typed-ember/glint) or other such tooling. It is\n *   *not* intended for public usage, and the specific mechanics it uses may\n *   change at any time. Although the signature produced by is part of Glimmer's\n *   public API the existence and mechanics of this specific symbol are *not*,\n *   so ***DO NOT RELY ON IT***.\n */\n// The conditional type here is because TS applies conditional types\n// distributively. This means that for union types, checks like `keyof T` get\n// all the keys from all elements of the union, instead of ending up as `never`\n// and then always falling into the `Signature` path instead of falling back to\n// the legacy args handling path.\nexport type ExpandSignature<T> = T extends any ? _ExpandSignature<T> : never;\n\n/**\n * @internal we use this type for convenience internally; inference means users\n *   should not normally need to name it\n */\nexport type Args<S> = ExpandSignature<S>['Args']['Named'];\n\n/**\n * The `Component` class defines an encapsulated UI element that is rendered to\n * the DOM. A component is made up of a template and, optionally, this component\n * object.\n *\n * ## Defining a Component\n *\n * To define a component, subclass `Component` and add your own properties,\n * methods and lifecycle hooks:\n *\n * ```ts\n * import Component from '@glimmer/component';\n *\n * export default class extends Component {\n * }\n * ```\n *\n * ## Lifecycle Hooks\n *\n * Lifecycle hooks allow you to respond to changes to a component, such as when\n * it gets created, rendered, updated or destroyed. To add a lifecycle hook to a\n * component, implement the hook as a method on your component subclass.\n *\n * For example, to be notified when Glimmer has rendered your component so you\n * can attach a legacy jQuery plugin, implement the `didInsertElement()` method:\n *\n * ```ts\n * import Component from '@glimmer/component';\n *\n * export default class extends Component {\n *   didInsertElement() {\n *     $(this.element).pickadate();\n *   }\n * }\n * ```\n *\n * ## Data for Templates\n *\n * `Component`s have two different kinds of data, or state, that can be\n * displayed in templates:\n *\n * 1. Arguments\n * 2. Properties\n *\n * Arguments are data that is passed in to a component from its parent\n * component. For example, if I have a `UserGreeting` component, I can pass it\n * a name and greeting to use:\n *\n * ```hbs\n * <UserGreeting @name=\"Ricardo\" @greeting=\"Olá\" />\n * ```\n *\n * Inside my `UserGreeting` template, I can access the `@name` and `@greeting`\n * arguments that I've been given:\n *\n * ```hbs\n * {{@greeting}}, {{@name}}!\n * ```\n *\n * Arguments are also available inside my component:\n *\n * ```ts\n * console.log(this.args.greeting); // prints \"Olá\"\n * ```\n *\n * Properties, on the other hand, are internal to the component and declared in\n * the class. You can use properties to store data that you want to show in the\n * template, or pass to another component as an argument.\n *\n * ```ts\n * import Component from '@glimmer/component';\n *\n * export default class extends Component {\n *   user = {\n *     name: 'Robbie'\n *   }\n * }\n * ```\n *\n * In the above example, we've defined a component with a `user` property that\n * contains an object with its own `name` property.\n *\n * We can render that property in our template:\n *\n * ```hbs\n * Hello, {{user.name}}!\n * ```\n *\n * We can also take that property and pass it as an argument to the\n * `UserGreeting` component we defined above:\n *\n * ```hbs\n * <UserGreeting @greeting=\"Hello\" @name={{user.name}} />\n * ```\n *\n * ## Arguments vs. Properties\n *\n * Remember, arguments are data that was given to your component by its parent\n * component, and properties are data your component has defined for itself.\n *\n * You can tell the difference between arguments and properties in templates\n * because arguments always start with an `@` sign (think \"A is for arguments\"):\n *\n * ```hbs\n * {{@firstName}}\n * ```\n *\n * We know that `@firstName` came from the parent component, not the current\n * component, because it starts with `@` and is therefore an argument.\n *\n * On the other hand, if we see:\n *\n * ```hbs\n * {{name}}\n * ```\n *\n * We know that `name` is a property on the component. If we want to know where\n * the data is coming from, we can go look at our component class to find out.\n *\n * Inside the component itself, arguments always show up inside the component's\n * `args` property. For example, if `{{@firstName}}` is `Tom` in the template,\n * inside the component `this.args.firstName` would also be `Tom`.\n */\nexport default class BaseComponent<S = unknown> {\n  /**\n   * Constructs a new component and assigns itself the passed properties. You\n   * should not construct new components yourself. Instead, Glimmer will\n   * instantiate new components automatically as it renders.\n   *\n   * @param owner\n   * @param args\n   */\n  constructor(owner: unknown, args: Args<S>) {\n    if (DEBUG && !(owner !== null && typeof owner === 'object' && ARGS_SET.has(args))) {\n      throw new Error(\n        `You must pass both the owner and args to super() in your component: ${\n          this.constructor.name\n        }. You can pass them directly, or use ...arguments to pass all arguments through.`\n      );\n    }\n\n    this.args = args;\n    setOwner(this, owner as any);\n  }\n\n  /**\n   * Named arguments passed to the component from its parent component.\n   * They can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.\n   *\n   * Say you have the following component, which will have two `args`, `firstName` and `lastName`:\n   *\n   * ```hbs\n   * <my-component @firstName=\"Arthur\" @lastName=\"Dent\" />\n   * ```\n   *\n   * If you needed to calculate `fullName` by combining both of them, you would do:\n   *\n   * ```ts\n   * didInsertElement() {\n   *   console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);\n   * }\n   * ```\n   *\n   * While in the template you could do:\n   *\n   * ```hbs\n   * <p>Welcome, {{@firstName}} {{@lastName}}!</p>\n   * ```\n   */\n  args: Readonly<Args<S>>;\n\n  get isDestroying(): boolean {\n    return isDestroying(this);\n  }\n\n  get isDestroyed(): boolean {\n    return isDestroyed(this);\n  }\n\n  /**\n   * Called before the component has been removed from the DOM.\n   */\n  willDestroy(): void {}\n}\n"],"sourceRoot":""}