@norith/glimmer-component 1.0.0

package/dist/commonjs/test/interactive/lifecycle-hook-test.js

@@ -0,0 +1,92 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glimmer_component_1 = __importDefault(require("@norith/glimmer-component"));
+const glimmer_tracking_1 = require("@norith/glimmer-tracking");
+const utils_1 = require("@norith/glimmer-core/test/utils");
+const glimmer_core_1 = require("@norith/glimmer-core");
+QUnit.module('[@glimmer/component] Lifecycle Hooks', () => {
+    utils_1.test('Lifecycle hook ordering', async function (assert) {
+        assert.expect(2);
+        let invocations = [];
+        let component1;
+        class HookLoggerComponent extends glimmer_component_1.default {
+            constructor(owner, args) {
+                super(owner, args);
+                invocations.push([this.args.name, 'constructor']);
+            }
+            willDestroy() {
+                invocations.push([this.args.name, 'willDestroy']);
+            }
+        }
+        class Component1 extends HookLoggerComponent {
+            constructor(owner, args) {
+                super(owner, args);
+                this.firstName = 'Chirag';
+                this.showChildren = true;
+                component1 = this;
+            }
+        }
+        __decorate([
+            glimmer_tracking_1.tracked
+        ], Component1.prototype, "firstName", void 0);
+        __decorate([
+            glimmer_tracking_1.tracked
+        ], Component1.prototype, "showChildren", void 0);
+        class Component2 extends HookLoggerComponent {
+        }
+        class Component3 extends HookLoggerComponent {
+        }
+        class Component4 extends HookLoggerComponent {
+        }
+        class Component5 extends HookLoggerComponent {
+        }
+        glimmer_core_1.setComponentTemplate(glimmer_core_1.precompileTemplate(`
+          {{#if this.showChildren}}
+            <Component2 @name="component2" @firstName={{this.firstName}} />
+            <Component3 @name="component3"/>
+          {{/if}}
+        `, {
+            strictMode: true,
+            scope: { Component2, Component3 },
+        }), Component1);
+        glimmer_core_1.setComponentTemplate(glimmer_core_1.precompileTemplate(`
+          {{@firstName}}
+          <Component4 @name="component4"/>
+          <Component5 @name="component5"/>
+        `, {
+            strictMode: true,
+            scope: { Component4, Component5 },
+        }), Component2);
+        const emptyTemplate = glimmer_core_1.precompileTemplate('');
+        glimmer_core_1.setComponentTemplate(emptyTemplate, Component3);
+        glimmer_core_1.setComponentTemplate(emptyTemplate, Component4);
+        glimmer_core_1.setComponentTemplate(emptyTemplate, Component5);
+        await utils_1.render(Component1, { args: { name: 'component1' } });
+        assert.deepEqual(invocations, [
+            ['component1', 'constructor'],
+            ['component2', 'constructor'],
+            ['component4', 'constructor'],
+            ['component5', 'constructor'],
+            ['component3', 'constructor'],
+        ]);
+        invocations = [];
+        component1.showChildren = false;
+        await utils_1.settled();
+        assert.deepEqual(invocations, [
+            ['component2', 'willDestroy'],
+            ['component4', 'willDestroy'],
+            ['component5', 'willDestroy'],
+            ['component3', 'willDestroy'],
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlmZWN5Y2xlLWhvb2stdGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL0BnbGltbWVyL2NvbXBvbmVudC90ZXN0L2ludGVyYWN0aXZlL2xpZmVjeWNsZS1ob29rLXRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFBQSxrRkFBa0Q7QUFDbEQsK0RBQW1EO0FBRW5ELDJEQUF3RTtBQUN4RSx1REFBZ0Y7QUFFaEYsS0FBSyxDQUFDLE1BQU0sQ0FBQyxzQ0FBc0MsRUFBRSxHQUFHLEVBQUU7SUFDeEQsWUFBSSxDQUFDLHlCQUF5QixFQUFFLEtBQUssV0FBVyxNQUFNO1FBQ3BELE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFFakIsSUFBSSxXQUFXLEdBQXVCLEVBQUUsQ0FBQztRQUN6QyxJQUFJLFVBQXNCLENBQUM7UUFFM0IsTUFBZSxtQkFBb0IsU0FBUSwyQkFBMkI7WUFDcEUsWUFBWSxLQUFhLEVBQUUsSUFBc0I7Z0JBQy9DLEtBQUssQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUM7Z0JBQ25CLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxhQUFhLENBQUMsQ0FBQyxDQUFDO1lBQ3BELENBQUM7WUFFRCxXQUFXO2dCQUNULFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxhQUFhLENBQUMsQ0FBQyxDQUFDO1lBQ3BELENBQUM7U0FDRjtRQUVELE1BQU0sVUFBVyxTQUFRLG1CQUFtQjtZQUkxQyxZQUFZLEtBQWEsRUFBRSxJQUFzQjtnQkFDL0MsS0FBSyxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFKWixjQUFTLEdBQUcsUUFBUSxDQUFDO2dCQUNyQixpQkFBWSxHQUFHLElBQUksQ0FBQztnQkFJM0IsVUFBVSxHQUFHLElBQUksQ0FBQztZQUNwQixDQUFDO1NBQ0Y7UUFQVTtZQUFSLDBCQUFPO3FEQUFzQjtRQUNyQjtZQUFSLDBCQUFPO3dEQUFxQjtRQU8vQixNQUFNLFVBQVcsU0FBUSxtQkFBbUI7U0FBRztRQUMvQyxNQUFNLFVBQVcsU0FBUSxtQkFBbUI7U0FBRztRQUMvQyxNQUFNLFVBQVcsU0FBUSxtQkFBbUI7U0FBRztRQUMvQyxNQUFNLFVBQVcsU0FBUSxtQkFBbUI7U0FBRztRQUUvQyxtQ0FBb0IsQ0FDbEIsaUNBQWtCLENBQ2hCOzs7OztTQUtDLEVBQ0Q7WUFDRSxVQUFVLEVBQUUsSUFBSTtZQUNoQixLQUFLLEVBQUUsRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFO1NBQ2xDLENBQ0YsRUFDRCxVQUFVLENBQ1gsQ0FBQztRQUVGLG1DQUFvQixDQUNsQixpQ0FBa0IsQ0FDaEI7Ozs7U0FJQyxFQUNEO1lBQ0UsVUFBVSxFQUFFLElBQUk7WUFDaEIsS0FBSyxFQUFFLEVBQUUsVUFBVSxFQUFFLFVBQVUsRUFBRTtTQUNsQyxDQUNGLEVBQ0QsVUFBVSxDQUNYLENBQUM7UUFFRixNQUFNLGFBQWEsR0FBRyxpQ0FBa0IsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUU3QyxtQ0FBb0IsQ0FBQyxhQUFhLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDaEQsbUNBQW9CLENBQUMsYUFBYSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ2hELG1DQUFvQixDQUFDLGFBQWEsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUVoRCxNQUFNLGNBQU0sQ0FBQyxVQUFVLEVBQUUsRUFBRSxJQUFJLEVBQUUsRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRTNELE1BQU0sQ0FBQyxTQUFTLENBQUMsV0FBVyxFQUFFO1lBQzVCLENBQUMsWUFBWSxFQUFFLGFBQWEsQ0FBQztZQUM3QixDQUFDLFlBQVksRUFBRSxhQUFhLENBQUM7WUFDN0IsQ0FBQyxZQUFZLEVBQUUsYUFBYSxDQUFDO1lBQzdCLENBQUMsWUFBWSxFQUFFLGFBQWEsQ0FBQztZQUM3QixDQUFDLFlBQVksRUFBRSxhQUFhLENBQUM7U0FDOUIsQ0FBQyxDQUFDO1FBRUgsV0FBVyxHQUFHLEVBQUUsQ0FBQztRQUVqQixVQUFXLENBQUMsWUFBWSxHQUFHLEtBQUssQ0FBQztRQUVqQyxNQUFNLGVBQU8sRUFBRSxDQUFDO1FBRWhCLE1BQU0sQ0FBQyxTQUFTLENBQUMsV0FBVyxFQUFFO1lBQzVCLENBQUMsWUFBWSxFQUFFLGFBQWEsQ0FBQztZQUM3QixDQUFDLFlBQVksRUFBRSxhQUFhLENBQUM7WUFDN0IsQ0FBQyxZQUFZLEVBQUUsYUFBYSxDQUFDO1lBQzdCLENBQUMsWUFBWSxFQUFFLGFBQWEsQ0FBQztTQUM5QixDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IENvbXBvbmVudCBmcm9tICdAbm9yaXRoL2dsaW1tZXItY29tcG9uZW50JztcbmltcG9ydCB7IHRyYWNrZWQgfSBmcm9tICdAbm9yaXRoL2dsaW1tZXItdHJhY2tpbmcnO1xuXG5pbXBvcnQgeyB0ZXN0LCByZW5kZXIsIHNldHRsZWQgfSBmcm9tICdAbm9yaXRoL2dsaW1tZXItY29yZS90ZXN0L3V0aWxzJztcbmltcG9ydCB7IHNldENvbXBvbmVudFRlbXBsYXRlLCBwcmVjb21waWxlVGVtcGxhdGUgfSBmcm9tICdAbm9yaXRoL2dsaW1tZXItY29yZSc7XG5cblFVbml0Lm1vZHVsZSgnW0BnbGltbWVyL2NvbXBvbmVudF0gTGlmZWN5Y2xlIEhvb2tzJywgKCkgPT4ge1xuICB0ZXN0KCdMaWZlY3ljbGUgaG9vayBvcmRlcmluZycsIGFzeW5jIGZ1bmN0aW9uIChhc3NlcnQpIHtcbiAgICBhc3NlcnQuZXhwZWN0KDIpO1xuXG4gICAgbGV0IGludm9jYXRpb25zOiBbc3RyaW5nLCBzdHJpbmddW10gPSBbXTtcbiAgICBsZXQgY29tcG9uZW50MTogQ29tcG9uZW50MTtcblxuICAgIGFic3RyYWN0IGNsYXNzIEhvb2tMb2dnZXJDb21wb25lbnQgZXh0ZW5kcyBDb21wb25lbnQ8eyBuYW1lOiBzdHJpbmcgfT4ge1xuICAgICAgY29uc3RydWN0b3Iob3duZXI6IG9iamVjdCwgYXJnczogeyBuYW1lOiBzdHJpbmcgfSkge1xuICAgICAgICBzdXBlcihvd25lciwgYXJncyk7XG4gICAgICAgIGludm9jYXRpb25zLnB1c2goW3RoaXMuYXJncy5uYW1lLCAnY29uc3RydWN0b3InXSk7XG4gICAgICB9XG5cbiAgICAgIHdpbGxEZXN0cm95KCk6IHZvaWQge1xuICAgICAgICBpbnZvY2F0aW9ucy5wdXNoKFt0aGlzLmFyZ3MubmFtZSwgJ3dpbGxEZXN0cm95J10pO1xuICAgICAgfVxuICAgIH1cblxuICAgIGNsYXNzIENvbXBvbmVudDEgZXh0ZW5kcyBIb29rTG9nZ2VyQ29tcG9uZW50IHtcbiAgICAgIEB0cmFja2VkIGZpcnN0TmFtZSA9ICdDaGlyYWcnO1xuICAgICAgQHRyYWNrZWQgc2hvd0NoaWxkcmVuID0gdHJ1ZTtcblxuICAgICAgY29uc3RydWN0b3Iob3duZXI6IG9iamVjdCwgYXJnczogeyBuYW1lOiBzdHJpbmcgfSkge1xuICAgICAgICBzdXBlcihvd25lciwgYXJncyk7XG4gICAgICAgIGNvbXBvbmVudDEgPSB0aGlzO1xuICAgICAgfVxuICAgIH1cbiAgICBjbGFzcyBDb21wb25lbnQyIGV4dGVuZHMgSG9va0xvZ2dlckNvbXBvbmVudCB7fVxuICAgIGNsYXNzIENvbXBvbmVudDMgZXh0ZW5kcyBIb29rTG9nZ2VyQ29tcG9uZW50IHt9XG4gICAgY2xhc3MgQ29tcG9uZW50NCBleHRlbmRzIEhvb2tMb2dnZXJDb21wb25lbnQge31cbiAgICBjbGFzcyBDb21wb25lbnQ1IGV4dGVuZHMgSG9va0xvZ2dlckNvbXBvbmVudCB7fVxuXG4gICAgc2V0Q29tcG9uZW50VGVtcGxhdGUoXG4gICAgICBwcmVjb21waWxlVGVtcGxhdGUoXG4gICAgICAgIGBcbiAgICAgICAgICB7eyNpZiB0aGlzLnNob3dDaGlsZHJlbn19XG4gICAgICAgICAgICA8Q29tcG9uZW50MiBAbmFtZT1cImNvbXBvbmVudDJcIiBAZmlyc3ROYW1lPXt7dGhpcy5maXJzdE5hbWV9fSAvPlxuICAgICAgICAgICAgPENvbXBvbmVudDMgQG5hbWU9XCJjb21wb25lbnQzXCIvPlxuICAgICAgICAgIHt7L2lmfX1cbiAgICAgICAgYCxcbiAgICAgICAge1xuICAgICAgICAgIHN0cmljdE1vZGU6IHRydWUsXG4gICAgICAgICAgc2NvcGU6IHsgQ29tcG9uZW50MiwgQ29tcG9uZW50MyB9LFxuICAgICAgICB9XG4gICAgICApLFxuICAgICAgQ29tcG9uZW50MVxuICAgICk7XG5cbiAgICBzZXRDb21wb25lbnRUZW1wbGF0ZShcbiAgICAgIHByZWNvbXBpbGVUZW1wbGF0ZShcbiAgICAgICAgYFxuICAgICAgICAgIHt7QGZpcnN0TmFtZX19XG4gICAgICAgICAgPENvbXBvbmVudDQgQG5hbWU9XCJjb21wb25lbnQ0XCIvPlxuICAgICAgICAgIDxDb21wb25lbnQ1IEBuYW1lPVwiY29tcG9uZW50NVwiLz5cbiAgICAgICAgYCxcbiAgICAgICAge1xuICAgICAgICAgIHN0cmljdE1vZGU6IHRydWUsXG4gICAgICAgICAgc2NvcGU6IHsgQ29tcG9uZW50NCwgQ29tcG9uZW50NSB9LFxuICAgICAgICB9XG4gICAgICApLFxuICAgICAgQ29tcG9uZW50MlxuICAgICk7XG5cbiAgICBjb25zdCBlbXB0eVRlbXBsYXRlID0gcHJlY29tcGlsZVRlbXBsYXRlKCcnKTtcblxuICAgIHNldENvbXBvbmVudFRlbXBsYXRlKGVtcHR5VGVtcGxhdGUsIENvbXBvbmVudDMpO1xuICAgIHNldENvbXBvbmVudFRlbXBsYXRlKGVtcHR5VGVtcGxhdGUsIENvbXBvbmVudDQpO1xuICAgIHNldENvbXBvbmVudFRlbXBsYXRlKGVtcHR5VGVtcGxhdGUsIENvbXBvbmVudDUpO1xuXG4gICAgYXdhaXQgcmVuZGVyKENvbXBvbmVudDEsIHsgYXJnczogeyBuYW1lOiAnY29tcG9uZW50MScgfSB9KTtcblxuICAgIGFzc2VydC5kZWVwRXF1YWwoaW52b2NhdGlvbnMsIFtcbiAgICAgIFsnY29tcG9uZW50MScsICdjb25zdHJ1Y3RvciddLFxuICAgICAgWydjb21wb25lbnQyJywgJ2NvbnN0cnVjdG9yJ10sXG4gICAgICBbJ2NvbXBvbmVudDQnLCAnY29uc3RydWN0b3InXSxcbiAgICAgIFsnY29tcG9uZW50NScsICdjb25zdHJ1Y3RvciddLFxuICAgICAgWydjb21wb25lbnQzJywgJ2NvbnN0cnVjdG9yJ10sXG4gICAgXSk7XG5cbiAgICBpbnZvY2F0aW9ucyA9IFtdO1xuXG4gICAgY29tcG9uZW50MSEuc2hvd0NoaWxkcmVuID0gZmFsc2U7XG5cbiAgICBhd2FpdCBzZXR0bGVkKCk7XG5cbiAgICBhc3NlcnQuZGVlcEVxdWFsKGludm9jYXRpb25zLCBbXG4gICAgICBbJ2NvbXBvbmVudDInLCAnd2lsbERlc3Ryb3knXSxcbiAgICAgIFsnY29tcG9uZW50NCcsICd3aWxsRGVzdHJveSddLFxuICAgICAgWydjb21wb25lbnQ1JywgJ3dpbGxEZXN0cm95J10sXG4gICAgICBbJ2NvbXBvbmVudDMnLCAnd2lsbERlc3Ryb3knXSxcbiAgICBdKTtcbiAgfSk7XG59KTtcbiJdfQ==

package/dist/modules/addon/-private/base-component-manager.d.ts

@@ -0,0 +1,13 @@
+import { ComponentManager, ComponentCapabilities } from '@norith/glimmer-core';
+import { Arguments } from '@glimmer/interfaces';
+import BaseComponent from './component';
+export interface Constructor<T> {
+    new (owner: unknown, args: Record<string, unknown>): T;
+}
+export default abstract class BaseComponentManager<GlimmerComponent extends BaseComponent> implements ComponentManager<GlimmerComponent> {
+    abstract capabilities: ComponentCapabilities;
+    private owner;
+    constructor(owner: unknown);
+    createComponent(ComponentClass: Constructor<GlimmerComponent>, args: Arguments): GlimmerComponent;
+    getContext(component: GlimmerComponent): GlimmerComponent;
+}

package/dist/modules/addon/-private/base-component-manager.js

@@ -0,0 +1,17 @@
+import { DEBUG } from '@glimmer/env';
+import { ARGS_SET } from './component';
+export default class BaseComponentManager {
+    constructor(owner) {
+        this.owner = owner;
+    }
+    createComponent(ComponentClass, args) {
+        if (DEBUG) {
+            ARGS_SET.set(args.named, true);
+        }
+        return new ComponentClass(this.owner, args.named);
+    }
+    getContext(component) {
+        return component;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/modules/addon/-private/component.d.ts

@@ -0,0 +1,244 @@
+export declare function setDestroying(component: GlimmerComponent<object>): void;
+export declare function setDestroyed(component: GlimmerComponent<object>): void;
+interface ArgsSetMap extends WeakMap<Args<unknown>, boolean> {
+    get<S>(key: Args<S>): boolean | undefined;
+    set<S>(key: Args<S>, value: boolean): this;
+    has<S>(key: Args<S>): boolean;
+}
+export declare let ARGS_SET: ArgsSetMap;
+declare const Empty: unique symbol;
+/**
+ * This provides us a way to have a "fallback" which represents an empty object,
+ * without the downsides of how TS treats `{}`. Specifically: this will
+ * correctly leverage "excess property checking" so that, given a component
+ * which has no named args, if someone invokes it with any named args, they will
+ * get a type error.
+ *
+ * @internal This is exported so declaration emit works (if it were not emitted,
+ *   declarations which fall back to it would not work). It is *not* intended for
+ *   public usage, and the specific mechanics it uses may change at any time.
+ *   The location of this export *is* part of the public API, because moving it
+ *   will break existing declarations, but is not legal for end users to import
+ *   themselves, so ***DO NOT RELY ON IT***.
+ */
+export declare type EmptyObject = {
+    [Empty]?: true;
+};
+declare type GetOrElse<Obj, K extends PropertyKey, Fallback> = Obj extends {
+    [Key in K]: infer U;
+} ? U : Fallback;
+/** Given a signature `S`, get back the `Args` type. */
+declare type ArgsFor<S> = S extends {
+    Args: infer Args;
+} ? Args extends {
+    Named?: object;
+    Positional?: unknown[];
+} ? {
+    Named: GetOrElse<S['Args'], 'Named', EmptyObject>;
+    Positional: GetOrElse<S['Args'], 'Positional', []>;
+} : {
+    Named: S['Args'];
+    Positional: [];
+} : {
+    Named: EmptyObject;
+    Positional: [];
+};
+declare type _ExpandSignature<T> = {
+    Element: GetOrElse<T, 'Element', null>;
+    Args: keyof T extends 'Args' | 'Element' | 'Blocks' ? ArgsFor<T> : {
+        Named: T;
+        Positional: [];
+    };
+    Blocks: T extends {
+        Blocks: infer Blocks;
+    } ? {
+        [Block in keyof Blocks]: Blocks[Block] extends unknown[] ? {
+            Params: {
+                Positional: Blocks[Block];
+            };
+        } : Blocks[Block];
+    } : EmptyObject;
+};
+/**
+ * Given any allowed shorthand form of a signature, desugars it to its full
+ * expanded type.
+ *
+ * @internal This is only exported so we can avoid duplicating it in
+ *   [Glint](https://github.com/typed-ember/glint) or other such tooling. It is
+ *   *not* intended for public usage, and the specific mechanics it uses may
+ *   change at any time. Although the signature produced by is part of Glimmer's
+ *   public API the existence and mechanics of this specific symbol are *not*,
+ *   so ***DO NOT RELY ON IT***.
+ */
+export declare type ExpandSignature<T> = T extends any ? _ExpandSignature<T> : never;
+/**
+ * @internal we use this type for convenience internally; inference means users
+ *   should not normally need to name it
+ */
+export declare type Args<S> = ExpandSignature<S>['Args']['Named'];
+/**
+ * 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 '@norith/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 '@norith/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 '@norith/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`.
+ */
+export default class GlimmerComponent<S = unknown> {
+    /**
+     * 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
+     */
+    constructor(owner: unknown, args: Args<S>);
+    /**
+     * Named arguments passed to the component from its parent component.
+     * They can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.
+     *
+     * Say you have the following component, which will have two `args`, `firstName` and `lastName`:
+     *
+     * ```hbs
+     * <my-component @firstName="Arthur" @lastName="Dent" />
+     * ```
+     *
+     * If you needed to calculate `fullName` by combining both of them, you would do:
+     *
+     * ```ts
+     * didInsertElement() {
+     *   console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);
+     * }
+     * ```
+     *
+     * While in the template you could do:
+     *
+     * ```hbs
+     * <p>Welcome, {{@firstName}} {{@lastName}}!</p>
+     * ```
+     */
+    readonly args: Readonly<Args<S>>;
+    get isDestroying(): boolean;
+    get isDestroyed(): boolean;
+    /**
+     * Called before the component has been removed from the DOM.
+     */
+    willDestroy(): void;
+}
+export {};

package/dist/modules/addon/-private/component.js

@@ -0,0 +1,167 @@
+import { DEBUG } from '@glimmer/env';
+const DESTROYING = new WeakMap();
+const DESTROYED = new WeakMap();
+export function setDestroying(component) {
+    DESTROYING.set(component, true);
+}
+export function setDestroyed(component) {
+    DESTROYED.set(component, true);
+}
+// 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 let 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 '@norith/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 '@norith/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 '@norith/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`.
+ */
+export default class GlimmerComponent {
+    /**
+     * 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
+     */
+    constructor(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;
+        DESTROYING.set(this, false);
+        DESTROYED.set(this, false);
+    }
+    get isDestroying() {
+        return DESTROYING.get(this) || false;
+    }
+    get isDestroyed() {
+        return DESTROYED.get(this) || false;
+    }
+    /**
+     * Called before the component has been removed from the DOM.
+     */
+    willDestroy() { } // eslint-disable-line @typescript-eslint/no-empty-function
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../packages/@glimmer/component/addon/-private/component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAErC,MAAM,UAAU,GAAG,IAAI,OAAO,EAAqC,CAAC;AACpE,MAAM,SAAS,GAAG,IAAI,OAAO,EAAqC,CAAC;AAEnE,MAAM,UAAU,aAAa,CAAC,SAAmC;IAC/D,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAClC,CAAC;AACD,MAAM,UAAU,YAAY,CAAC,SAAmC;IAC9D,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AACjC,CAAC;AAYD,+EAA+E;AAC/E,kEAAkE;AAClE,MAAM,CAAC,IAAI,QAAoB,CAAC;AAEhC,IAAI,KAAK,EAAE;IACT,QAAQ,GAAG,IAAI,OAAO,EAAgB,CAAC;CACxC;AA2ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0HG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC;;;;;;;OAOG;IACH,YAAY,KAAc,EAAE,IAAa;QACvC,IAAI,KAAK,IAAI,CAAC,CAAC,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE;YACjF,MAAM,IAAI,KAAK,CACb,uEAAuE,IAAI,CAAC,WAAW,CAAC,IAAI,kFAAkF,CAC/K,CAAC;SACH;QAED,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QAEjB,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC5B,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC7B,CAAC;IA4BD,IAAI,YAAY;QACd,OAAO,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC;IACvC,CAAC;IAED,IAAI,WAAW;QACb,OAAO,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,WAAW,KAAU,CAAC,CAAC,2DAA2D;CACnF","sourcesContent":["import { DEBUG } from '@glimmer/env';\n\nconst DESTROYING = new WeakMap<GlimmerComponent<object>, boolean>();\nconst DESTROYED = new WeakMap<GlimmerComponent<object>, boolean>();\n\nexport function setDestroying(component: GlimmerComponent<object>): void {\n  DESTROYING.set(component, true);\n}\nexport function setDestroyed(component: GlimmerComponent<object>): void {\n  DESTROYED.set(component, true);\n}\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  has<S>(key: Args<S>): boolean;\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 * 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.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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 '@norith/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 '@norith/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 '@norith/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 GlimmerComponent<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: ${this.constructor.name}. You can pass them directly, or use ...arguments to pass all arguments through.`\n      );\n    }\n\n    this.args = args;\n\n    DESTROYING.set(this, false);\n    DESTROYED.set(this, false);\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  readonly args: Readonly<Args<S>>;\n\n  get isDestroying(): boolean {\n    return DESTROYING.get(this) || false;\n  }\n\n  get isDestroyed(): boolean {\n    return DESTROYED.get(this) || false;\n  }\n\n  /**\n   * Called before the component has been removed from the DOM.\n   */\n  willDestroy(): void {} // eslint-disable-line @typescript-eslint/no-empty-function\n}\n"]}

package/dist/modules/index.d.ts

@@ -0,0 +1 @@
+export { default } from './src/component';

package/dist/modules/index.js

@@ -0,0 +1,2 @@
+export { default } from './src/component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9AZ2xpbW1lci9jb21wb25lbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZGVmYXVsdCB9IGZyb20gJy4vc3JjL2NvbXBvbmVudCc7XG4iXX0=

package/dist/modules/src/component-manager.d.ts

@@ -0,0 +1,12 @@
+import BaseComponentManager from '../addon/-private/base-component-manager';
+import GlimmerComponent from '../addon/-private/component';
+/**
+ * This component manager runs in Glimmer.js environments and extends the base component manager to:
+ *
+ * 1. Implement a lightweight destruction protocol (currently not deferred, like in Ember)
+ * 2. Invoke legacy component lifecycle hooks (didInsertElement and didUpdate)
+ */
+export default class GlimmerComponentManager extends BaseComponentManager<GlimmerComponent> {
+    capabilities: import("@norith/glimmer-core").ComponentCapabilities;
+    destroyComponent(component: GlimmerComponent): void;
+}

package/dist/modules/src/component-manager.js

@@ -0,0 +1,24 @@
+import { componentCapabilities } from '@norith/glimmer-core';
+import BaseComponentManager from '../addon/-private/base-component-manager';
+import { setDestroying, setDestroyed } from '../addon/-private/component';
+const CAPABILITIES = componentCapabilities('3.13', {
+    destructor: true,
+});
+/**
+ * This component manager runs in Glimmer.js environments and extends the base component manager to:
+ *
+ * 1. Implement a lightweight destruction protocol (currently not deferred, like in Ember)
+ * 2. Invoke legacy component lifecycle hooks (didInsertElement and didUpdate)
+ */
+export default class GlimmerComponentManager extends BaseComponentManager {
+    constructor() {
+        super(...arguments);
+        this.capabilities = CAPABILITIES;
+    }
+    destroyComponent(component) {
+        setDestroying(component);
+        component.willDestroy();
+        setDestroyed(component);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/modules/src/component.d.ts

@@ -0,0 +1,4 @@
+import _GlimmerComponent, { Args } from '../addon/-private/component';
+export default class GlimmerComponent<S = unknown> extends _GlimmerComponent<S> {
+    constructor(owner: object, args: Args<S>);
+}

package/dist/modules/src/component.js

@@ -0,0 +1,17 @@
+import { setComponentManager, setOwner } from '@norith/glimmer-core';
+import GlimmerComponentManager from './component-manager';
+import _GlimmerComponent from '../addon/-private/component';
+import { DEBUG } from '@glimmer/env';
+export default class GlimmerComponent extends _GlimmerComponent {
+    constructor(owner, args) {
+        super(owner, args);
+        if (DEBUG && !(owner !== null && typeof owner === 'object')) {
+            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.`);
+        }
+        setOwner(this, owner);
+    }
+}
+setComponentManager((owner) => {
+    return new GlimmerComponentManager(owner);
+}, GlimmerComponent);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/modules/test/index.d.ts

@@ -0,0 +1 @@
+import './interactive';

package/dist/modules/test/index.js

@@ -0,0 +1,2 @@
+import './interactive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9AZ2xpbW1lci9jb21wb25lbnQvdGVzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAnLi9pbnRlcmFjdGl2ZSc7XG4iXX0=