@norith/glimmer-tracking 1.0.0

package/dist/modules/test/fixtures/typescript.js

@@ -0,0 +1,280 @@
+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;
+};
+import { cached, tracked } from '@norith/glimmer-tracking';
+export class Tom {
+    constructor() {
+        this.firstName = 'Tom';
+    }
+}
+__decorate([
+    tracked
+], Tom.prototype, "firstName", void 0);
+export class Toran {
+    constructor() {
+        this.firstName = 'Toran';
+        this.lastName = 'Billups';
+    }
+}
+__decorate([
+    tracked
+], Toran.prototype, "firstName", void 0);
+class FrozenToran {
+    constructor() {
+        this.firstName = 'Toran';
+        this.lastName = 'Billups';
+    }
+}
+__decorate([
+    tracked
+], FrozenToran.prototype, "firstName", void 0);
+Object.freeze(FrozenToran);
+export { FrozenToran };
+export class PersonWithCount {
+    constructor() {
+        this._firstName = 'Tom';
+        this._count = 0;
+    }
+    get firstName() {
+        return this._firstName + this._count++;
+    }
+    set firstName(value) {
+        this._firstName = value;
+    }
+}
+__decorate([
+    tracked
+], PersonWithCount.prototype, "_firstName", void 0);
+export class PersonWithSalutation {
+    constructor() {
+        this.firstName = 'Tom';
+        this.lastName = 'Dale';
+    }
+    get salutation() {
+        return `Hello, ${this.fullName}!`;
+    }
+    get fullName() {
+        return `${this.firstName} ${this.lastName}`;
+    }
+    set fullName(fullName) {
+        const [firstName, lastName] = fullName.split(' ');
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+}
+__decorate([
+    tracked
+], PersonWithSalutation.prototype, "firstName", void 0);
+__decorate([
+    tracked
+], PersonWithSalutation.prototype, "lastName", void 0);
+export class Contact {
+    constructor(person, email) {
+        this.person = person;
+        this.email = email;
+    }
+    get contact() {
+        return `${this.person} @ ${this.email}`;
+    }
+}
+__decorate([
+    tracked
+], Contact.prototype, "email", void 0);
+__decorate([
+    tracked
+], Contact.prototype, "person", void 0);
+export class PersonForContact {
+    constructor() {
+        this.firstName = 'Tom';
+        this.lastName = 'Dale';
+    }
+    get salutation() {
+        return `Hello, ${this.fullName}!`;
+    }
+    get fullName() {
+        return `${this.firstName} ${this.lastName}`;
+    }
+    set fullName(fullName) {
+        const [firstName, lastName] = fullName.split(' ');
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+    toString() {
+        return this.fullName;
+    }
+}
+__decorate([
+    tracked
+], PersonForContact.prototype, "firstName", void 0);
+__decorate([
+    tracked
+], PersonForContact.prototype, "lastName", void 0);
+export function createClassWithTrackedGetter() {
+    class PersonWithTrackedGetter {
+        constructor() {
+            this.firstName = 'Tom';
+        }
+        get salutation() {
+            return `Hello, ${this.firstName} ${this.lastName}!`;
+        }
+    }
+    __decorate([
+        tracked
+    ], PersonWithTrackedGetter.prototype, "firstName", void 0);
+    __decorate([
+        tracked
+    ], PersonWithTrackedGetter.prototype, "lastName", void 0);
+    __decorate([
+        tracked
+    ], PersonWithTrackedGetter.prototype, "salutation", null);
+    return new PersonWithTrackedGetter();
+}
+export function createClassWithCachedProperty() {
+    class PersonWithCachedProperty {
+        constructor() {
+            this.firstName = 'Tom';
+        }
+    }
+    __decorate([
+        cached
+    ], PersonWithCachedProperty.prototype, "firstName", void 0);
+    return new PersonWithCachedProperty();
+}
+export function createClassWithTrackedSetter() {
+    class PersonWithTrackedSetter {
+        constructor() {
+            this.firstName = 'Tom';
+        }
+        // @ts-ignore
+        set fullName(fullName) {
+            const [firstName, lastName] = fullName.split(' ');
+            this.firstName = firstName;
+            this.lastName = lastName;
+        }
+    }
+    __decorate([
+        tracked
+    ], PersonWithTrackedSetter.prototype, "firstName", void 0);
+    __decorate([
+        tracked
+    ], PersonWithTrackedSetter.prototype, "lastName", void 0);
+    __decorate([
+        tracked
+    ], PersonWithTrackedSetter.prototype, "fullName", null);
+    return new PersonWithTrackedSetter();
+}
+export function createClassWithCachedSetter() {
+    class PersonWithCachedSetter {
+        constructor() {
+            this.firstName = 'Tom';
+        }
+        // @ts-ignore
+        set fullName(fullName) {
+            const [firstName, lastName] = fullName.split(' ');
+            this.firstName = firstName;
+            this.lastName = lastName;
+        }
+    }
+    __decorate([
+        tracked
+    ], PersonWithCachedSetter.prototype, "firstName", void 0);
+    __decorate([
+        tracked
+    ], PersonWithCachedSetter.prototype, "lastName", void 0);
+    __decorate([
+        cached
+    ], PersonWithCachedSetter.prototype, "fullName", null);
+    return new PersonWithCachedSetter();
+}
+export function createClassWithTrackedDependentKeys() {
+    class DependentKeysAreCool {
+        constructor() {
+            this.firstName = 'Tom';
+            this.lastName = 'Dale';
+        }
+        // @ts-ignore
+        fullName() {
+            return `${this.firstName} ${this.lastName}`;
+        }
+    }
+    __decorate([
+        tracked('firstName', 'lastName')
+    ], DependentKeysAreCool.prototype, "fullName", null);
+    __decorate([
+        tracked
+    ], DependentKeysAreCool.prototype, "firstName", void 0);
+    __decorate([
+        tracked
+    ], DependentKeysAreCool.prototype, "lastName", void 0);
+    return new DependentKeysAreCool();
+}
+export function createClassWithCachedDependentKeys() {
+    class DependentKeysAreCool {
+        constructor() {
+            this.firstName = 'Tom';
+            this.lastName = 'Dale';
+        }
+        // @ts-ignore
+        fullName() {
+            return `${this.firstName} ${this.lastName}`;
+        }
+    }
+    __decorate([
+        cached('firstName', 'lastName')
+    ], DependentKeysAreCool.prototype, "fullName", null);
+    __decorate([
+        tracked
+    ], DependentKeysAreCool.prototype, "firstName", void 0);
+    __decorate([
+        tracked
+    ], DependentKeysAreCool.prototype, "lastName", void 0);
+    return new DependentKeysAreCool();
+}
+export function createClassWithTrackedAsDecoratorFactory() {
+    class DependentKeysAreCool {
+        constructor() {
+            this.firstName = 'Tom';
+            this.lastName = 'Dale';
+        }
+        // @ts-ignore
+        fullName() {
+            return `${this.firstName} ${this.lastName}`;
+        }
+    }
+    __decorate([
+        tracked()
+    ], DependentKeysAreCool.prototype, "fullName", null);
+    __decorate([
+        tracked
+    ], DependentKeysAreCool.prototype, "firstName", void 0);
+    __decorate([
+        tracked
+    ], DependentKeysAreCool.prototype, "lastName", void 0);
+    return new DependentKeysAreCool();
+}
+export function createClassWithCachedAsDecoratorFactory() {
+    class DependentKeysAreCool {
+        constructor() {
+            this.firstName = 'Tom';
+            this.lastName = 'Dale';
+        }
+        // @ts-ignore
+        fullName() {
+            return `${this.firstName} ${this.lastName}`;
+        }
+    }
+    __decorate([
+        cached()
+    ], DependentKeysAreCool.prototype, "fullName", null);
+    __decorate([
+        tracked
+    ], DependentKeysAreCool.prototype, "firstName", void 0);
+    __decorate([
+        tracked
+    ], DependentKeysAreCool.prototype, "lastName", void 0);
+    return new DependentKeysAreCool();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript.js","sourceRoot":"","sources":["../../../../../../packages/@glimmer/tracking/test/fixtures/typescript.ts"],"names":[],"mappings":"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","sourcesContent":["import { cached, tracked } from '@norith/glimmer-tracking';\n\nexport class Tom {\n  @tracked firstName = 'Tom';\n}\n\nexport class Toran {\n  @tracked firstName = 'Toran';\n  lastName = 'Billups';\n}\n\nclass FrozenToran {\n  @tracked firstName = 'Toran';\n  lastName = 'Billups';\n}\n\nObject.freeze(FrozenToran);\n\nexport { FrozenToran };\n\nexport class PersonWithCount {\n  @tracked _firstName = 'Tom';\n  _count = 0;\n\n  get firstName() {\n    return this._firstName + this._count++;\n  }\n\n  set firstName(value) {\n    this._firstName = value;\n  }\n}\n\nexport class PersonWithSalutation {\n  get salutation() {\n    return `Hello, ${this.fullName}!`;\n  }\n\n  get fullName() {\n    return `${this.firstName} ${this.lastName}`;\n  }\n\n  set fullName(fullName) {\n    const [firstName, lastName] = fullName.split(' ');\n    this.firstName = firstName;\n    this.lastName = lastName;\n  }\n\n  @tracked firstName = 'Tom';\n  @tracked lastName = 'Dale';\n}\n\nexport class Contact {\n  @tracked email: string;\n  @tracked person: PersonForContact;\n\n  constructor(person: PersonForContact, email: string) {\n    this.person = person;\n    this.email = email;\n  }\n\n  get contact(): string {\n    return `${this.person} @ ${this.email}`;\n  }\n}\n\nexport class PersonForContact {\n  get salutation() {\n    return `Hello, ${this.fullName}!`;\n  }\n\n  get fullName(): string {\n    return `${this.firstName} ${this.lastName}`;\n  }\n\n  set fullName(fullName: string) {\n    const [firstName, lastName] = fullName.split(' ');\n    this.firstName = firstName;\n    this.lastName = lastName;\n  }\n\n  toString() {\n    return this.fullName;\n  }\n\n  @tracked firstName = 'Tom';\n  @tracked lastName = 'Dale';\n}\n\nexport function createClassWithTrackedGetter(): any {\n  class PersonWithTrackedGetter {\n    @tracked firstName = 'Tom';\n    @tracked lastName: any;\n\n    @tracked get salutation() {\n      return `Hello, ${this.firstName} ${this.lastName}!`;\n    }\n  }\n\n  return new PersonWithTrackedGetter();\n}\n\nexport function createClassWithCachedProperty(): any {\n  class PersonWithCachedProperty {\n    @cached firstName = 'Tom';\n  }\n\n  return new PersonWithCachedProperty();\n}\n\nexport function createClassWithTrackedSetter(): any {\n  class PersonWithTrackedSetter {\n    @tracked firstName = 'Tom';\n    @tracked lastName: any;\n\n    // @ts-ignore\n    @tracked set fullName(fullName) {\n      const [firstName, lastName] = fullName.split(' ');\n      this.firstName = firstName;\n      this.lastName = lastName;\n    }\n  }\n\n  return new PersonWithTrackedSetter();\n}\n\nexport function createClassWithCachedSetter(): any {\n  class PersonWithCachedSetter {\n    @tracked firstName = 'Tom';\n    @tracked lastName: any;\n\n    // @ts-ignore\n    @cached set fullName(fullName) {\n      const [firstName, lastName] = fullName.split(' ');\n      this.firstName = firstName;\n      this.lastName = lastName;\n    }\n  }\n\n  return new PersonWithCachedSetter();\n}\n\nexport function createClassWithTrackedDependentKeys(): any {\n  class DependentKeysAreCool {\n    // @ts-ignore\n    @tracked('firstName', 'lastName') fullName() {\n      return `${this.firstName} ${this.lastName}`;\n    }\n\n    @tracked firstName = 'Tom';\n    @tracked lastName = 'Dale';\n  }\n  return new DependentKeysAreCool();\n}\n\nexport function createClassWithCachedDependentKeys(): any {\n  class DependentKeysAreCool {\n    // @ts-ignore\n    @cached('firstName', 'lastName') fullName() {\n      return `${this.firstName} ${this.lastName}`;\n    }\n\n    @tracked firstName = 'Tom';\n    @tracked lastName = 'Dale';\n  }\n  return new DependentKeysAreCool();\n}\n\nexport function createClassWithTrackedAsDecoratorFactory(): any {\n  class DependentKeysAreCool {\n    // @ts-ignore\n    @tracked() fullName() {\n      return `${this.firstName} ${this.lastName}`;\n    }\n\n    @tracked firstName = 'Tom';\n    @tracked lastName = 'Dale';\n  }\n  return new DependentKeysAreCool();\n}\n\nexport function createClassWithCachedAsDecoratorFactory(): any {\n  class DependentKeysAreCool {\n    // @ts-ignore\n    @cached() fullName() {\n      return `${this.firstName} ${this.lastName}`;\n    }\n\n    @tracked firstName = 'Tom';\n    @tracked lastName = 'Dale';\n  }\n  return new DependentKeysAreCool();\n}\n"]}

package/dist/modules/test/helpers/tags.d.ts

@@ -0,0 +1,2 @@
+import { Tag } from '@glimmer/validator';
+export declare function assertValidAfterUnrelatedBump(tag: Tag, snapshot: number): void;

package/dist/modules/test/helpers/tags.js

@@ -0,0 +1,6 @@
+import { bump, validateTag } from '@glimmer/validator';
+export function assertValidAfterUnrelatedBump(tag, snapshot) {
+    bump();
+    QUnit.assert.strictEqual(validateTag(tag, snapshot), true, 'tag is still valid after an unrelated bump');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL0BnbGltbWVyL3RyYWNraW5nL3Rlc3QvaGVscGVycy90YWdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQU8sV0FBVyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFNUQsTUFBTSxVQUFVLDZCQUE2QixDQUFDLEdBQVEsRUFBRSxRQUFnQjtJQUN0RSxJQUFJLEVBQUUsQ0FBQztJQUVQLEtBQUssQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUN0QixXQUFXLENBQUMsR0FBRyxFQUFFLFFBQVEsQ0FBQyxFQUMxQixJQUFJLEVBQ0osNENBQTRDLENBQzdDLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYnVtcCwgVGFnLCB2YWxpZGF0ZVRhZyB9IGZyb20gJ0BnbGltbWVyL3ZhbGlkYXRvcic7XG5cbmV4cG9ydCBmdW5jdGlvbiBhc3NlcnRWYWxpZEFmdGVyVW5yZWxhdGVkQnVtcCh0YWc6IFRhZywgc25hcHNob3Q6IG51bWJlcik6IHZvaWQge1xuICBidW1wKCk7XG5cbiAgUVVuaXQuYXNzZXJ0LnN0cmljdEVxdWFsKFxuICAgIHZhbGlkYXRlVGFnKHRhZywgc25hcHNob3QpLFxuICAgIHRydWUsXG4gICAgJ3RhZyBpcyBzdGlsbCB2YWxpZCBhZnRlciBhbiB1bnJlbGF0ZWQgYnVtcCdcbiAgKTtcbn1cbiJdfQ==

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

@@ -0,0 +1,2 @@
+import './tracked-decorator-test';
+import './cached-decorator-test';

package/dist/modules/test/index.js

@@ -0,0 +1,3 @@
+import './tracked-decorator-test';
+import './cached-decorator-test';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9AZ2xpbW1lci90cmFja2luZy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sMEJBQTBCLENBQUM7QUFDbEMsT0FBTyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAnLi90cmFja2VkLWRlY29yYXRvci10ZXN0JztcbmltcG9ydCAnLi9jYWNoZWQtZGVjb3JhdG9yLXRlc3QnO1xuIl19

package/dist/modules/test/tracked-decorator-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/test/tracked-decorator-test.js

@@ -0,0 +1,161 @@
+/* tslint:disable:no-unused-expression */
+const { test } = QUnit;
+import { DEBUG } from '@glimmer/env';
+import { track, valueForTag, validateTag } from '@glimmer/validator';
+import * as TSFixtures from './fixtures/typescript';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import * as BabelFixtures from './fixtures/babel';
+import { assertValidAfterUnrelatedBump } from './helpers/tags';
+[
+    ['Babel', BabelFixtures],
+    ['TypeScript', TSFixtures],
+].forEach(([compiler, F]) => {
+    QUnit.module(`[@glimmer/tracking] Tracked Property Decorators with ${compiler}`);
+    test('tracked properties can be read and written to', (assert) => {
+        const obj = new F.Tom();
+        assert.strictEqual(obj.firstName, 'Tom');
+        obj.firstName = 'Edsger';
+        assert.strictEqual(obj.firstName, 'Edsger');
+    });
+    test('can request a tag for a property', (assert) => {
+        const obj = new F.Tom();
+        assert.strictEqual(obj.firstName, 'Tom');
+        const tag = track(() => {
+            obj.firstName;
+        });
+        let snapshot = valueForTag(tag);
+        assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');
+        obj.firstName = 'Edsger';
+        assert.strictEqual(validateTag(tag, snapshot), false, 'tag is invalidated after property is set');
+        snapshot = valueForTag(tag);
+        assert.strictEqual(validateTag(tag, snapshot), true, 'tag is valid on the second check');
+        assertValidAfterUnrelatedBump(tag, snapshot);
+    });
+    test('can request a tag from a frozen class instance', (assert) => {
+        const obj = Object.freeze(new F.Toran());
+        assert.strictEqual(obj.firstName, 'Toran');
+        assert.strictEqual(obj.lastName, 'Billups');
+        // Explicitly annotated tracked properties
+        let tag = track(() => {
+            obj.firstName;
+        });
+        let snapshot = valueForTag(tag);
+        assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');
+        snapshot = valueForTag(tag);
+        assert.strictEqual(validateTag(tag, snapshot), true, 'tag is still valid');
+        // Non-tracked data properties
+        tag = track(() => {
+            obj.lastName;
+        });
+        snapshot = valueForTag(tag);
+        assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');
+        snapshot = valueForTag(tag);
+        assert.strictEqual(validateTag(tag, snapshot), true, 'tag is still valid');
+        assertValidAfterUnrelatedBump(tag, snapshot);
+    });
+    test('can request a tag from an instance of a frozen class', (assert) => {
+        const obj = Object.freeze(new F.FrozenToran());
+        assert.strictEqual(obj.firstName, 'Toran');
+        const tag = track(() => {
+            obj.firstName;
+        });
+        let snapshot = valueForTag(tag);
+        assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');
+        snapshot = valueForTag(tag);
+        assert.strictEqual(validateTag(tag, snapshot), true, 'tag is still valid');
+        assertValidAfterUnrelatedBump(tag, snapshot);
+    });
+    test('can track a getter', (assert) => {
+        const obj = new F.PersonWithCount();
+        assert.strictEqual(obj.firstName, 'Tom0');
+        assert.strictEqual(obj.firstName, 'Tom1');
+        const tag = track(() => {
+            obj.firstName;
+        });
+        let snapshot = valueForTag(tag);
+        assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');
+        assert.strictEqual(obj.firstName, 'Tom3');
+        assert.ok(validateTag(tag, snapshot), 'reading from property does not invalidate the tag');
+        obj.firstName = 'Edsger';
+        assert.strictEqual(validateTag(tag, snapshot), false, 'tag is invalidated after property is set');
+        snapshot = valueForTag(tag);
+        assertValidAfterUnrelatedBump(tag, snapshot);
+    });
+    test('getters are invalidated when their dependencies are invalidated', (assert) => {
+        const obj = new F.PersonWithSalutation();
+        assert.strictEqual(obj.salutation, 'Hello, Tom Dale!', `the saluation field is valid`);
+        assert.strictEqual(obj.fullName, 'Tom Dale', `the fullName field is valid`);
+        const tag = track(() => {
+            obj.salutation;
+        });
+        let snapshot = valueForTag(tag);
+        assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');
+        obj.firstName = 'Edsger';
+        obj.lastName = 'Dijkstra';
+        assert.strictEqual(validateTag(tag, snapshot), false, 'tag is invalidated after chained dependency is set');
+        assert.strictEqual(obj.fullName, 'Edsger Dijkstra');
+        assert.strictEqual(obj.salutation, 'Hello, Edsger Dijkstra!');
+        snapshot = valueForTag(tag);
+        assert.strictEqual(validateTag(tag, snapshot), true);
+        obj.fullName = 'Alan Kay';
+        assert.strictEqual(validateTag(tag, snapshot), false, 'tag is invalidated after chained dependency is set');
+        assert.strictEqual(obj.fullName, 'Alan Kay');
+        assert.strictEqual(obj.firstName, 'Alan');
+        assert.strictEqual(obj.lastName, 'Kay');
+        assert.strictEqual(obj.salutation, 'Hello, Alan Kay!');
+        snapshot = valueForTag(tag);
+        assert.strictEqual(validateTag(tag, snapshot), true);
+        assertValidAfterUnrelatedBump(tag, snapshot);
+    });
+    test('nested @tracked in multiple objects', (assert) => {
+        const obj = new F.Contact(new F.PersonForContact(), 'tom@example.com');
+        assert.strictEqual(obj.contact, 'Tom Dale @ tom@example.com', `the contact field is valid`);
+        assert.strictEqual(obj.person.fullName, 'Tom Dale', `the fullName field is valid`);
+        const person = obj.person;
+        const tag = track(() => {
+            obj.contact;
+        });
+        let snapshot = valueForTag(tag);
+        assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');
+        person.firstName = 'Edsger';
+        person.lastName = 'Dijkstra';
+        assert.strictEqual(validateTag(tag, snapshot), false, 'tag is invalidated after nested dependency is set');
+        assert.strictEqual(person.fullName, 'Edsger Dijkstra');
+        assert.strictEqual(obj.contact, 'Edsger Dijkstra @ tom@example.com');
+        snapshot = valueForTag(tag);
+        assert.strictEqual(validateTag(tag, snapshot), true);
+        person.fullName = 'Alan Kay';
+        assert.strictEqual(validateTag(tag, snapshot), false, 'tag is invalidated after chained dependency is set');
+        assert.strictEqual(person.fullName, 'Alan Kay');
+        assert.strictEqual(person.firstName, 'Alan');
+        assert.strictEqual(person.lastName, 'Kay');
+        assert.strictEqual(obj.contact, 'Alan Kay @ tom@example.com');
+        snapshot = valueForTag(tag);
+        assert.strictEqual(validateTag(tag, snapshot), true);
+        obj.email = 'alan@example.com';
+        assert.strictEqual(validateTag(tag, snapshot), false, 'tag is invalidated after chained dependency is set');
+        assert.strictEqual(person.fullName, 'Alan Kay');
+        assert.strictEqual(person.firstName, 'Alan');
+        assert.strictEqual(person.lastName, 'Kay');
+        assert.strictEqual(obj.contact, 'Alan Kay @ alan@example.com');
+        snapshot = valueForTag(tag);
+        assert.strictEqual(validateTag(tag, snapshot), true);
+        assertValidAfterUnrelatedBump(tag, snapshot);
+    });
+    if (DEBUG) {
+        test('Tracked decorator with a getter throws an error', (assert) => {
+            assert.throws(F.createClassWithTrackedGetter);
+        });
+        test('Tracked decorator with a setter throws an error', (assert) => {
+            assert.throws(F.createClassWithTrackedSetter);
+        });
+        test('Tracked decorator with arguments throws an error', function (assert) {
+            assert.throws(F.createClassWithTrackedDependentKeys, /@tracked\('firstName', 'lastName'\)/, 'the correct error is thrown');
+        });
+        test('Using @tracked as a decorator factory throws an error', function (assert) {
+            assert.throws(F.createClassWithTrackedAsDecoratorFactory, /@tracked\(\)/, 'The correct error is thrown');
+        });
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tracked-decorator-test.js","sourceRoot":"","sources":["../../../../../packages/@glimmer/tracking/test/tracked-decorator-test.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable:no-unused-expression */\nconst { test } = QUnit;\n\nimport { DEBUG } from '@glimmer/env';\nimport { track, valueForTag, validateTag } from '@glimmer/validator';\n\nimport * as TSFixtures from './fixtures/typescript';\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport * as BabelFixtures from './fixtures/babel';\nimport { assertValidAfterUnrelatedBump } from './helpers/tags';\n\n[\n  ['Babel', BabelFixtures],\n  ['TypeScript', TSFixtures],\n].forEach(([compiler, F]) => {\n  QUnit.module(`[@glimmer/tracking] Tracked Property Decorators with ${compiler}`);\n\n  test('tracked properties can be read and written to', (assert) => {\n    const obj = new F.Tom();\n    assert.strictEqual(obj.firstName, 'Tom');\n    obj.firstName = 'Edsger';\n    assert.strictEqual(obj.firstName, 'Edsger');\n  });\n\n  test('can request a tag for a property', (assert) => {\n    const obj = new F.Tom();\n    assert.strictEqual(obj.firstName, 'Tom');\n\n    const tag = track(() => {\n      obj.firstName;\n    });\n    let snapshot = valueForTag(tag);\n    assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');\n\n    obj.firstName = 'Edsger';\n    assert.strictEqual(\n      validateTag(tag, snapshot),\n      false,\n      'tag is invalidated after property is set'\n    );\n    snapshot = valueForTag(tag);\n    assert.strictEqual(validateTag(tag, snapshot), true, 'tag is valid on the second check');\n\n    assertValidAfterUnrelatedBump(tag, snapshot);\n  });\n\n  test('can request a tag from a frozen class instance', (assert) => {\n    const obj = Object.freeze(new F.Toran());\n    assert.strictEqual(obj.firstName, 'Toran');\n    assert.strictEqual(obj.lastName, 'Billups');\n\n    // Explicitly annotated tracked properties\n    let tag = track(() => {\n      obj.firstName;\n    });\n    let snapshot = valueForTag(tag);\n    assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');\n    snapshot = valueForTag(tag);\n    assert.strictEqual(validateTag(tag, snapshot), true, 'tag is still valid');\n\n    // Non-tracked data properties\n    tag = track(() => {\n      obj.lastName;\n    });\n    snapshot = valueForTag(tag);\n    assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');\n    snapshot = valueForTag(tag);\n    assert.strictEqual(validateTag(tag, snapshot), true, 'tag is still valid');\n\n    assertValidAfterUnrelatedBump(tag, snapshot);\n  });\n\n  test('can request a tag from an instance of a frozen class', (assert) => {\n    const obj = Object.freeze(new F.FrozenToran());\n\n    assert.strictEqual(obj.firstName, 'Toran');\n\n    const tag = track(() => {\n      obj.firstName;\n    });\n    let snapshot = valueForTag(tag);\n    assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');\n    snapshot = valueForTag(tag);\n    assert.strictEqual(validateTag(tag, snapshot), true, 'tag is still valid');\n\n    assertValidAfterUnrelatedBump(tag, snapshot);\n  });\n\n  test('can track a getter', (assert) => {\n    const obj = new F.PersonWithCount();\n    assert.strictEqual(obj.firstName, 'Tom0');\n    assert.strictEqual(obj.firstName, 'Tom1');\n\n    const tag = track(() => {\n      obj.firstName;\n    });\n    let snapshot = valueForTag(tag);\n    assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');\n\n    assert.strictEqual(obj.firstName, 'Tom3');\n    assert.ok(validateTag(tag, snapshot), 'reading from property does not invalidate the tag');\n\n    obj.firstName = 'Edsger';\n    assert.strictEqual(\n      validateTag(tag, snapshot),\n      false,\n      'tag is invalidated after property is set'\n    );\n    snapshot = valueForTag(tag);\n\n    assertValidAfterUnrelatedBump(tag, snapshot);\n  });\n\n  test('getters are invalidated when their dependencies are invalidated', (assert) => {\n    const obj = new F.PersonWithSalutation();\n    assert.strictEqual(obj.salutation, 'Hello, Tom Dale!', `the saluation field is valid`);\n    assert.strictEqual(obj.fullName, 'Tom Dale', `the fullName field is valid`);\n\n    const tag = track(() => {\n      obj.salutation;\n    });\n    let snapshot = valueForTag(tag);\n    assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');\n\n    obj.firstName = 'Edsger';\n    obj.lastName = 'Dijkstra';\n    assert.strictEqual(\n      validateTag(tag, snapshot),\n      false,\n      'tag is invalidated after chained dependency is set'\n    );\n    assert.strictEqual(obj.fullName, 'Edsger Dijkstra');\n    assert.strictEqual(obj.salutation, 'Hello, Edsger Dijkstra!');\n\n    snapshot = valueForTag(tag);\n    assert.strictEqual(validateTag(tag, snapshot), true);\n\n    obj.fullName = 'Alan Kay';\n    assert.strictEqual(\n      validateTag(tag, snapshot),\n      false,\n      'tag is invalidated after chained dependency is set'\n    );\n    assert.strictEqual(obj.fullName, 'Alan Kay');\n    assert.strictEqual(obj.firstName, 'Alan');\n    assert.strictEqual(obj.lastName, 'Kay');\n    assert.strictEqual(obj.salutation, 'Hello, Alan Kay!');\n\n    snapshot = valueForTag(tag);\n    assert.strictEqual(validateTag(tag, snapshot), true);\n\n    assertValidAfterUnrelatedBump(tag, snapshot);\n  });\n\n  test('nested @tracked in multiple objects', (assert) => {\n    const obj = new F.Contact(new F.PersonForContact(), 'tom@example.com');\n    assert.strictEqual(obj.contact, 'Tom Dale @ tom@example.com', `the contact field is valid`);\n    assert.strictEqual(obj.person.fullName, 'Tom Dale', `the fullName field is valid`);\n    const person = obj.person;\n\n    const tag = track(() => {\n      obj.contact;\n    });\n    let snapshot = valueForTag(tag);\n    assert.ok(validateTag(tag, snapshot), 'tag should be valid to start');\n\n    person.firstName = 'Edsger';\n    person.lastName = 'Dijkstra';\n    assert.strictEqual(\n      validateTag(tag, snapshot),\n      false,\n      'tag is invalidated after nested dependency is set'\n    );\n    assert.strictEqual(person.fullName, 'Edsger Dijkstra');\n    assert.strictEqual(obj.contact, 'Edsger Dijkstra @ tom@example.com');\n\n    snapshot = valueForTag(tag);\n    assert.strictEqual(validateTag(tag, snapshot), true);\n\n    person.fullName = 'Alan Kay';\n    assert.strictEqual(\n      validateTag(tag, snapshot),\n      false,\n      'tag is invalidated after chained dependency is set'\n    );\n    assert.strictEqual(person.fullName, 'Alan Kay');\n    assert.strictEqual(person.firstName, 'Alan');\n    assert.strictEqual(person.lastName, 'Kay');\n    assert.strictEqual(obj.contact, 'Alan Kay @ tom@example.com');\n\n    snapshot = valueForTag(tag);\n    assert.strictEqual(validateTag(tag, snapshot), true);\n\n    obj.email = 'alan@example.com';\n    assert.strictEqual(\n      validateTag(tag, snapshot),\n      false,\n      'tag is invalidated after chained dependency is set'\n    );\n    assert.strictEqual(person.fullName, 'Alan Kay');\n    assert.strictEqual(person.firstName, 'Alan');\n    assert.strictEqual(person.lastName, 'Kay');\n    assert.strictEqual(obj.contact, 'Alan Kay @ alan@example.com');\n\n    snapshot = valueForTag(tag);\n    assert.strictEqual(validateTag(tag, snapshot), true);\n\n    assertValidAfterUnrelatedBump(tag, snapshot);\n  });\n\n  if (DEBUG) {\n    test('Tracked decorator with a getter throws an error', (assert) => {\n      assert.throws(F.createClassWithTrackedGetter);\n    });\n\n    test('Tracked decorator with a setter throws an error', (assert) => {\n      assert.throws(F.createClassWithTrackedSetter);\n    });\n\n    test('Tracked decorator with arguments throws an error', function (assert) {\n      assert.throws(\n        F.createClassWithTrackedDependentKeys,\n        /@tracked\\('firstName', 'lastName'\\)/,\n        'the correct error is thrown'\n      );\n    });\n\n    test('Using @tracked as a decorator factory throws an error', function (assert) {\n      assert.throws(\n        F.createClassWithTrackedAsDecoratorFactory,\n        /@tracked\\(\\)/,\n        'The correct error is thrown'\n      );\n    });\n  }\n});\n"]}

package/ember-addon-main.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  name: '@norith/glimmer-tracking',
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@norith/glimmer-tracking",
+  "version": "1.0.0",
+  "description": "Glimmer property tracking library",
+  "keywords": [
+    "ember-addon"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/snorith/glimmer.js.git"
+  },
+  "license": "MIT",
+  "contributors": [
+    "Dan Gebhardt <dan@cerebris.com>",
+    "Tom Dale <tom@tomdale.net>"
+  ],
+  "main": "dist/commonjs/index.js",
+  "module": "dist/modules/index.js",
+  "files": [
+    "dist",
+    "ember-addon-main.js"
+  ],
+  "dependencies": {
+    "@glimmer/env": "^0.1.7",
+    "@glimmer/validator": "0.84.0"
+  },
+  "devDependencies": {
+    "@glimmer/application-test-helpers": "^1.0.0",
+    "@glimmer/compiler": "0.84.0",
+    "@glimmer/interfaces": "0.84.0",
+    "@glimmer/resolver": "^0.4.3",
+    "@glimmer/wire-format": "0.84.0"
+  },
+  "ember-addon": {
+    "main": "ember-addon-main.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}