@norith/glimmer-tracking 1.0.0

package/README.md

@@ -0,0 +1,44 @@
+# @glimmer/tracking
+
+[![npm version](https://badge.fury.io/js/%40glimmer%2Ftracking.svg)](https://badge.fury.io/js/%40glimmer%2Ftracking)
+[![CI](https://github.com/glimmerjs/glimmer.js/workflows/CI/badge.svg)](https://github.com/glimmerjs/glimmer.js/actions?query=workflow%3ACI)
+
+## Installation
+
+Add this package to your project with Yarn:
+
+```bash
+yarn add -D @glimmer/tracking
+```
+
+Or alternatively with npm:
+
+```bash
+npm install --save-dev @glimmer/tracking
+```
+
+## Usage
+
+To use this in a Glimmer application, import the package and export an extended class:
+
+```ts
+import Component from '@glimmer/component';
+import { tracked } from '@glimmer/tracking';
+
+export default class MyComponent extends Component {
+  @tracked foo;
+}
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/glimmerjs/glimmer.js.
+
+## Acknowledgements
+
+Thanks to [Monegraph](http://monegraph.com) for funding the initial development
+of this library.
+
+## License
+
+MIT License.

package/dist/commonjs/index.d.ts

@@ -0,0 +1,2 @@
+export { cached } from './src/cached';
+export { tracked } from './src/tracked';

package/dist/commonjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracked = exports.cached = void 0;
+var cached_1 = require("./src/cached");
+Object.defineProperty(exports, "cached", { enumerable: true, get: function () { return cached_1.cached; } });
+var tracked_1 = require("./src/tracked");
+Object.defineProperty(exports, "tracked", { enumerable: true, get: function () { return tracked_1.tracked; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9AZ2xpbW1lci90cmFja2luZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx1Q0FBc0M7QUFBN0IsZ0dBQUEsTUFBTSxPQUFBO0FBQ2YseUNBQXdDO0FBQS9CLGtHQUFBLE9BQU8sT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGNhY2hlZCB9IGZyb20gJy4vc3JjL2NhY2hlZCc7XG5leHBvcnQgeyB0cmFja2VkIH0gZnJvbSAnLi9zcmMvdHJhY2tlZCc7XG4iXX0=

package/dist/commonjs/src/cached.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @decorator
+ *
+ * The `@cached` decorator can be used on getters in order to cache the return
+ * value of the getter. This is useful when a getter is expensive and used very
+ * often.
+ *
+ *
+ * @example
+ *
+ * in this guest list class, we have the `sortedGuests`
+ * getter that sorts the guests alphabetically:
+ *
+ * ```js
+ * import { tracked } from '@norith/glimmer-tracking';
+ *
+ * class GuestList {
+ *   @tracked guests = ['Zoey', 'Tomster'];
+ *
+ *   get sortedGuests() {
+ *     return this.guests.slice().sort()
+ *   }
+ * }
+ * ```
+ *
+ * Every time `sortedGuests` is accessed, a new array will be created and sorted,
+ * because JavaScript getters do not cache by default. When the guest list is
+ * small, like the one in the example, this is not a problem. However, if the guest
+ * list were to grow very large, it would mean that we would be doing a large
+ * amount of work each time we accessed `sortedGetters`. With `@cached`, we can
+ * cache the value instead:
+ *
+ * ```js
+ * import { tracked, cached } from '@norith/glimmer-tracking';
+ *
+ * class GuestList {
+ *   @tracked guests = ['Zoey', 'Tomster'];
+ *
+ *   @cached
+ *   get sortedGuests() {
+ *     return this.guests.slice().sort()
+ *   }
+ * }
+ * ```
+ *
+ * Now the `sortedGuests` getter will be cached based on _autotracking_. It will
+ * only rerun and create a new sorted array when the `guests` tracked property is
+ * updated.
+ *
+ * In general, you should avoid using `@cached` unless you have confirmed that the
+ * getter you are decorating is computationally expensive. `@cached` adds a small
+ * amount of overhead to the getter, making it more expensive. While this overhead
+ * is small, if `@cached` is overused it can add up to a large impact overall in
+ * your app. Many getters and tracked properties are only accessed once, rendered,
+ * and then never rerendered, so adding `@cached` when it is unnecessary can
+ * negatively impact performance.
+ */
+export declare const cached: PropertyDecorator;

package/dist/commonjs/src/cached.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cached = void 0;
+const env_1 = require("@glimmer/env");
+const validator_1 = require("@glimmer/validator");
+/**
+ * @decorator
+ *
+ * The `@cached` decorator can be used on getters in order to cache the return
+ * value of the getter. This is useful when a getter is expensive and used very
+ * often.
+ *
+ *
+ * @example
+ *
+ * in this guest list class, we have the `sortedGuests`
+ * getter that sorts the guests alphabetically:
+ *
+ * ```js
+ * import { tracked } from '@norith/glimmer-tracking';
+ *
+ * class GuestList {
+ *   @tracked guests = ['Zoey', 'Tomster'];
+ *
+ *   get sortedGuests() {
+ *     return this.guests.slice().sort()
+ *   }
+ * }
+ * ```
+ *
+ * Every time `sortedGuests` is accessed, a new array will be created and sorted,
+ * because JavaScript getters do not cache by default. When the guest list is
+ * small, like the one in the example, this is not a problem. However, if the guest
+ * list were to grow very large, it would mean that we would be doing a large
+ * amount of work each time we accessed `sortedGetters`. With `@cached`, we can
+ * cache the value instead:
+ *
+ * ```js
+ * import { tracked, cached } from '@norith/glimmer-tracking';
+ *
+ * class GuestList {
+ *   @tracked guests = ['Zoey', 'Tomster'];
+ *
+ *   @cached
+ *   get sortedGuests() {
+ *     return this.guests.slice().sort()
+ *   }
+ * }
+ * ```
+ *
+ * Now the `sortedGuests` getter will be cached based on _autotracking_. It will
+ * only rerun and create a new sorted array when the `guests` tracked property is
+ * updated.
+ *
+ * In general, you should avoid using `@cached` unless you have confirmed that the
+ * getter you are decorating is computationally expensive. `@cached` adds a small
+ * amount of overhead to the getter, making it more expensive. While this overhead
+ * is small, if `@cached` is overused it can add up to a large impact overall in
+ * your app. Many getters and tracked properties are only accessed once, rendered,
+ * and then never rerendered, so adding `@cached` when it is unnecessary can
+ * negatively impact performance.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const cached = (...args) => {
+    const [target, key, descriptor] = args;
+    // Error on `@cached()`, `@cached(...args)`, and `@cached propName = value;`
+    if (env_1.DEBUG && target === undefined)
+        throwCachedExtraneousParens();
+    if (env_1.DEBUG &&
+        (typeof target !== 'object' ||
+            typeof key !== 'string' ||
+            typeof descriptor !== 'object' ||
+            args.length !== 3)) {
+        throwCachedInvalidArgsError(args);
+    }
+    if (env_1.DEBUG && (!('get' in descriptor) || typeof descriptor.get !== 'function')) {
+        throwCachedGetterOnlyError(key);
+    }
+    const caches = new WeakMap();
+    const getter = descriptor.get;
+    descriptor.get = function () {
+        if (!caches.has(this)) {
+            caches.set(this, validator_1.createCache(getter.bind(this)));
+        }
+        return validator_1.getValue(caches.get(this));
+    };
+};
+exports.cached = cached;
+function throwCachedExtraneousParens() {
+    throw new Error('You attempted to use @cached(), which is not necessary nor supported. Remove the parentheses and you will be good to go!');
+}
+function throwCachedGetterOnlyError(key) {
+    throw new Error(`The @cached decorator must be applied to getters. '${key}' is not a getter.`);
+}
+function throwCachedInvalidArgsError(args = []) {
+    throw new Error(`You attempted to use @cached on with ${args.length > 1 ? 'arguments' : 'an argument'} ( @cached(${args
+        .map((d) => `'${d}'`)
+        .join(', ')}), which is not supported. Dependencies are automatically tracked, so you can just use ${'`@cached`'}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commonjs/src/tracked.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @decorator
+ *
+ * Marks a property as tracked.
+ *
+ * By default, a component's properties are expected to be static,
+ * meaning you are not able to update them and have the template update accordingly.
+ * Marking a property as tracked means that when that property changes,
+ * a rerender of the component is scheduled so the template is kept up to date.
+ *
+ * @example
+ *
+ * ```typescript
+ * import Component from '@norith/glimmer-component';
+ * import { tracked } from '@norith/glimmer-tracking';
+ *
+ * export default class MyComponent extends Component {
+ *    @tracked
+ *    remainingApples = 10
+ * }
+ * ```
+ *
+ * When something changes the component's `remainingApples` property, the rerender
+ * will be scheduled.
+ *
+ * @example Computed Properties
+ *
+ * In the case that you have a getter that depends on other properties, tracked
+ * properties accessed within the getter will automatically be tracked for you.
+ * That means when any of those dependent tracked properties is changed, a
+ * rerender of the component will be scheduled.
+ *
+ * In the following example we have two properties,
+ * `eatenApples`, and `remainingApples`.
+ *
+ *
+ * ```typescript
+ * import Component from '@norith/glimmer-component';
+ * import { tracked } from '@norith/glimmer-tracking';
+ *
+ * const totalApples = 100;
+ *
+ * export default class MyComponent extends Component {
+ *    @tracked
+ *    eatenApples = 0
+ *
+ *    get remainingApples() {
+ *      return totalApples - this.eatenApples;
+ *    }
+ *
+ *    increment() {
+ *      this.eatenApples = this.eatenApples + 1;
+ *    }
+ *  }
+ * ```
+ */
+export declare const tracked: PropertyDecorator;

package/dist/commonjs/src/tracked.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracked = void 0;
+const env_1 = require("@glimmer/env");
+const validator_1 = require("@glimmer/validator");
+/**
+ * @decorator
+ *
+ * Marks a property as tracked.
+ *
+ * By default, a component's properties are expected to be static,
+ * meaning you are not able to update them and have the template update accordingly.
+ * Marking a property as tracked means that when that property changes,
+ * a rerender of the component is scheduled so the template is kept up to date.
+ *
+ * @example
+ *
+ * ```typescript
+ * import Component from '@norith/glimmer-component';
+ * import { tracked } from '@norith/glimmer-tracking';
+ *
+ * export default class MyComponent extends Component {
+ *    @tracked
+ *    remainingApples = 10
+ * }
+ * ```
+ *
+ * When something changes the component's `remainingApples` property, the rerender
+ * will be scheduled.
+ *
+ * @example Computed Properties
+ *
+ * In the case that you have a getter that depends on other properties, tracked
+ * properties accessed within the getter will automatically be tracked for you.
+ * That means when any of those dependent tracked properties is changed, a
+ * rerender of the component will be scheduled.
+ *
+ * In the following example we have two properties,
+ * `eatenApples`, and `remainingApples`.
+ *
+ *
+ * ```typescript
+ * import Component from '@norith/glimmer-component';
+ * import { tracked } from '@norith/glimmer-tracking';
+ *
+ * const totalApples = 100;
+ *
+ * export default class MyComponent extends Component {
+ *    @tracked
+ *    eatenApples = 0
+ *
+ *    get remainingApples() {
+ *      return totalApples - this.eatenApples;
+ *    }
+ *
+ *    increment() {
+ *      this.eatenApples = this.eatenApples + 1;
+ *    }
+ *  }
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const tracked = (...args) => {
+    const [target, key, descriptor] = args;
+    // Error on `@tracked()`, `@tracked(...args)`, and `@tracked get propName()`
+    if (env_1.DEBUG && typeof target === 'string')
+        throwTrackedWithArgumentsError(args);
+    if (env_1.DEBUG && target === undefined)
+        throwTrackedWithEmptyArgumentsError();
+    if (env_1.DEBUG && descriptor && descriptor.get)
+        throwTrackedComputedPropertyError();
+    if (descriptor) {
+        return descriptorForField(target, key, descriptor);
+    }
+    // In TypeScript's implementation, decorators on simple class fields do not
+    // receive a descriptor, so we define the property on the target directly.
+    Object.defineProperty(target, key, descriptorForField(target, key));
+};
+exports.tracked = tracked;
+function throwTrackedComputedPropertyError() {
+    throw new Error(`The @tracked decorator does not need to be applied to getters. Properties implemented using a getter will recompute automatically when any tracked properties they access change.`);
+}
+function throwTrackedWithArgumentsError(args) {
+    throw new Error(`You attempted to use @tracked with ${args.length > 1 ? 'arguments' : 'an argument'} ( @tracked(${args
+        .map((d) => `'${d}'`)
+        .join(', ')}) ), which is no longer necessary nor supported. Dependencies are now automatically tracked, so you can just use ${'`@tracked`'}.`);
+}
+function throwTrackedWithEmptyArgumentsError() {
+    throw new Error('You attempted to use @tracked(), which is no longer necessary nor supported. Remove the parentheses and you will be good to go!');
+}
+function descriptorForField(_target, key, desc) {
+    if (env_1.DEBUG && desc && (desc.value || desc.get || desc.set)) {
+        throw new Error(`You attempted to use @tracked on ${String(key)}, but that element is not a class field. @tracked is only usable on class fields. Native getters and setters will autotrack add any tracked fields they encounter, so there is no need mark getters and setters with @tracked.`);
+    }
+    const { getter, setter } = validator_1.trackedData(key, desc && desc.initializer);
+    return {
+        enumerable: true,
+        configurable: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        get() {
+            return getter(this);
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        set(newValue) {
+            setter(this, newValue);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tracked.js","sourceRoot":"","sources":["../../../../../packages/@glimmer/tracking/src/tracked.ts"],"names":[],"mappings":";;;AAAA,sCAAqC;AACrC,kDAAiD;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,8DAA8D;AACvD,MAAM,OAAO,GAAsB,CAAC,GAAG,IAAW,EAAE,EAAE;IAC3D,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC;IAEvC,4EAA4E;IAC5E,IAAI,WAAK,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,8BAA8B,CAAC,IAAI,CAAC,CAAC;IAC9E,IAAI,WAAK,IAAI,MAAM,KAAK,SAAS;QAAE,mCAAmC,EAAE,CAAC;IACzE,IAAI,WAAK,IAAI,UAAU,IAAI,UAAU,CAAC,GAAG;QAAE,iCAAiC,EAAE,CAAC;IAE/E,IAAI,UAAU,EAAE;QACd,OAAO,kBAAkB,CAAC,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;KACpD;IACD,2EAA2E;IAC3E,0EAA0E;IAC1E,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,kBAAkB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;AACtE,CAAC,CAAC;AAdW,QAAA,OAAO,WAclB;AAEF,SAAS,iCAAiC;IACxC,MAAM,IAAI,KAAK,CACb,mLAAmL,CACpL,CAAC;AACJ,CAAC;AAED,SAAS,8BAA8B,CAAC,IAAe;IACrD,MAAM,IAAI,KAAK,CACb,sCACE,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,aAClC,eAAe,IAAI;SAChB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;SACpB,IAAI,CACH,IAAI,CACL,oHAAoH,YAAY,GAAG,CACvI,CAAC;AACJ,CAAC;AAED,SAAS,mCAAmC;IAC1C,MAAM,IAAI,KAAK,CACb,iIAAiI,CAClI,CAAC;AACJ,CAAC;AAkBD,SAAS,kBAAkB,CACzB,OAAU,EACV,GAAM,EACN,IAAkC;IAElC,IAAI,WAAK,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE;QACzD,MAAM,IAAI,KAAK,CACb,oCAAoC,MAAM,CACxC,GAAG,CACJ,gOAAgO,CAClO,CAAC;KACH;IAED,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,uBAAW,CAAO,GAAG,EAAE,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC;IAE5E,OAAO;QACL,UAAU,EAAE,IAAI;QAChB,YAAY,EAAE,IAAI;QAElB,8DAA8D;QAC9D,GAAG;YACD,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC;QACtB,CAAC;QAED,8DAA8D;QAC9D,GAAG,CAAU,QAAa;YACxB,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACzB,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { DEBUG } from '@glimmer/env';\nimport { trackedData } from '@glimmer/validator';\n\n/**\n * @decorator\n *\n * Marks a property as tracked.\n *\n * By default, a component's properties are expected to be static,\n * meaning you are not able to update them and have the template update accordingly.\n * Marking a property as tracked means that when that property changes,\n * a rerender of the component is scheduled so the template is kept up to date.\n *\n * @example\n *\n * ```typescript\n * import Component from '@norith/glimmer-component';\n * import { tracked } from '@norith/glimmer-tracking';\n *\n * export default class MyComponent extends Component {\n *    @tracked\n *    remainingApples = 10\n * }\n * ```\n *\n * When something changes the component's `remainingApples` property, the rerender\n * will be scheduled.\n *\n * @example Computed Properties\n *\n * In the case that you have a getter that depends on other properties, tracked\n * properties accessed within the getter will automatically be tracked for you.\n * That means when any of those dependent tracked properties is changed, a\n * rerender of the component will be scheduled.\n *\n * In the following example we have two properties,\n * `eatenApples`, and `remainingApples`.\n *\n *\n * ```typescript\n * import Component from '@norith/glimmer-component';\n * import { tracked } from '@norith/glimmer-tracking';\n *\n * const totalApples = 100;\n *\n * export default class MyComponent extends Component {\n *    @tracked\n *    eatenApples = 0\n *\n *    get remainingApples() {\n *      return totalApples - this.eatenApples;\n *    }\n *\n *    increment() {\n *      this.eatenApples = this.eatenApples + 1;\n *    }\n *  }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const tracked: PropertyDecorator = (...args: any[]) => {\n  const [target, key, descriptor] = args;\n\n  // Error on `@tracked()`, `@tracked(...args)`, and `@tracked get propName()`\n  if (DEBUG && typeof target === 'string') throwTrackedWithArgumentsError(args);\n  if (DEBUG && target === undefined) throwTrackedWithEmptyArgumentsError();\n  if (DEBUG && descriptor && descriptor.get) throwTrackedComputedPropertyError();\n\n  if (descriptor) {\n    return descriptorForField(target, key, descriptor);\n  }\n  // In TypeScript's implementation, decorators on simple class fields do not\n  // receive a descriptor, so we define the property on the target directly.\n  Object.defineProperty(target, key, descriptorForField(target, key));\n};\n\nfunction throwTrackedComputedPropertyError(): never {\n  throw new Error(\n    `The @tracked decorator does not need to be applied to getters. Properties implemented using a getter will recompute automatically when any tracked properties they access change.`\n  );\n}\n\nfunction throwTrackedWithArgumentsError(args: unknown[]): never {\n  throw new Error(\n    `You attempted to use @tracked with ${\n      args.length > 1 ? 'arguments' : 'an argument'\n    } ( @tracked(${args\n      .map((d) => `'${d}'`)\n      .join(\n        ', '\n      )}) ), which is no longer necessary nor supported. Dependencies are now automatically tracked, so you can just use ${'`@tracked`'}.`\n  );\n}\n\nfunction throwTrackedWithEmptyArgumentsError(): never {\n  throw new Error(\n    'You attempted to use @tracked(), which is no longer necessary nor supported. Remove the parentheses and you will be good to go!'\n  );\n}\n\n/**\n * Whenever a tracked computed property is entered, the current tracker is\n * saved off and a new tracker is replaced.\n *\n * Any tracked properties consumed are added to the current tracker.\n *\n * When a tracked computed property is exited, the tracker's tags are\n * combined and added to the parent tracker.\n *\n * The consequence is that each tracked computed property has a tag\n * that corresponds to the tracked properties consumed inside of\n * itself, including child tracked computed properties.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype DecoratorPropertyDescriptor = (PropertyDescriptor & { initializer?: any }) | undefined;\n\nfunction descriptorForField<T extends object, K extends keyof T>(\n  _target: T,\n  key: K,\n  desc?: DecoratorPropertyDescriptor\n): PropertyDescriptor {\n  if (DEBUG && desc && (desc.value || desc.get || desc.set)) {\n    throw new Error(\n      `You attempted to use @tracked on ${String(\n        key\n      )}, but that element is not a class field. @tracked is only usable on class fields. Native getters and setters will autotrack add any tracked fields they encounter, so there is no need mark getters and setters with @tracked.`\n    );\n  }\n\n  const { getter, setter } = trackedData<T, K>(key, desc && desc.initializer);\n\n  return {\n    enumerable: true,\n    configurable: true,\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    get(this: T): any {\n      return getter(this);\n    },\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    set(this: T, newValue: any): void {\n      setter(this, newValue);\n    },\n  };\n}\n"]}

package/dist/commonjs/test/cached-decorator-test.d.ts

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

package/dist/commonjs/test/cached-decorator-test.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+const { test } = QUnit;
+const env_1 = require("@glimmer/env");
+const glimmer_tracking_1 = require("@norith/glimmer-tracking");
+const TSFixtures = __importStar(require("./fixtures/typescript"));
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const BabelFixtures = __importStar(require("./fixtures/babel"));
+QUnit.module('[@glimmer/tracking] @cached Decorators');
+test('it works', function (assert) {
+    class Person {
+        constructor() {
+            this.firstName = 'Jen';
+            this.lastName = 'Weber';
+        }
+        get fullName() {
+            const fullName = `${this.firstName} ${this.lastName}`;
+            assert.step(fullName);
+            return fullName;
+        }
+    }
+    __decorate([
+        glimmer_tracking_1.tracked
+    ], Person.prototype, "firstName", void 0);
+    __decorate([
+        glimmer_tracking_1.tracked
+    ], Person.prototype, "lastName", void 0);
+    __decorate([
+        glimmer_tracking_1.cached
+    ], Person.prototype, "fullName", null);
+    const person = new Person();
+    assert.verifySteps([], 'getter is not called after class initialization');
+    assert.strictEqual(person.fullName, 'Jen Weber');
+    assert.verifySteps(['Jen Weber'], 'getter was called after property access');
+    assert.strictEqual(person.fullName, 'Jen Weber');
+    assert.verifySteps([], 'getter was not called again after repeated property access');
+    person.firstName = 'Kenneth';
+    assert.verifySteps([], 'changing a property does not trigger an eager re-computation');
+    assert.strictEqual(person.fullName, 'Kenneth Weber');
+    assert.verifySteps(['Kenneth Weber'], 'accessing the property triggers a re-computation');
+    assert.strictEqual(person.fullName, 'Kenneth Weber');
+    assert.verifySteps([], 'getter was not called again after repeated property access');
+    person.lastName = 'Larsen';
+    assert.verifySteps([], 'changing a property does not trigger an eager re-computation');
+    assert.strictEqual(person.fullName, 'Kenneth Larsen');
+    assert.verifySteps(['Kenneth Larsen'], 'accessing the property triggers a re-computation');
+});
+// https://github.com/ember-polyfills/ember-cached-decorator-polyfill/issues/7
+test('it has a separate cache per class instance', function (assert) {
+    class Person {
+        constructor(firstName, lastName) {
+            this.firstName = firstName;
+            this.lastName = lastName;
+        }
+        get fullName() {
+            const fullName = `${this.firstName} ${this.lastName}`;
+            assert.step(fullName);
+            return fullName;
+        }
+    }
+    __decorate([
+        glimmer_tracking_1.tracked
+    ], Person.prototype, "firstName", void 0);
+    __decorate([
+        glimmer_tracking_1.tracked
+    ], Person.prototype, "lastName", void 0);
+    __decorate([
+        glimmer_tracking_1.cached
+    ], Person.prototype, "fullName", null);
+    const jen = new Person('Jen', 'Weber');
+    const chris = new Person('Chris', 'Garrett');
+    assert.verifySteps([], 'getter is not called after class initialization');
+    assert.strictEqual(jen.fullName, 'Jen Weber');
+    assert.verifySteps(['Jen Weber'], 'getter was called after property access');
+    assert.strictEqual(jen.fullName, 'Jen Weber');
+    assert.verifySteps([], 'getter was not called again after repeated property access');
+    assert.strictEqual(chris.fullName, 'Chris Garrett', 'other instance has a different value');
+    assert.verifySteps(['Chris Garrett'], 'getter was called after property access');
+    assert.strictEqual(chris.fullName, 'Chris Garrett');
+    assert.verifySteps([], 'getter was not called again after repeated property access');
+    chris.lastName = 'Manson';
+    assert.verifySteps([], 'changing a property does not trigger an eager re-computation');
+    assert.strictEqual(jen.fullName, 'Jen Weber', 'other instance is unaffected');
+    assert.verifySteps([], 'getter was not called again after repeated property access');
+    assert.strictEqual(chris.fullName, 'Chris Manson');
+    assert.verifySteps(['Chris Manson'], 'getter was called after property access');
+    assert.strictEqual(jen.fullName, 'Jen Weber', 'other instance is unaffected');
+    assert.verifySteps([], 'getter was not called again after repeated property access');
+});
+[
+    ['Babel', BabelFixtures],
+    ['TypeScript', TSFixtures],
+].forEach(([compiler, F]) => {
+    QUnit.module(`[@glimmer/tracking] Cached Property Decorators with ${compiler}`);
+    if (env_1.DEBUG) {
+        test('Cached decorator on a property throws an error', (assert) => {
+            assert.throws(F.createClassWithCachedProperty);
+        });
+        test('Cached decorator with a setter throws an error', (assert) => {
+            assert.throws(F.createClassWithCachedSetter);
+        });
+        test('Cached decorator with arguments throws an error', function (assert) {
+            assert.throws(F.createClassWithCachedDependentKeys, /@cached\('firstName', 'lastName'\)/, 'the correct error is thrown');
+        });
+        test('Using @cached as a decorator factory throws an error', function (assert) {
+            assert.throws(F.createClassWithCachedAsDecoratorFactory, /@cached\(\)/, 'The correct error is thrown');
+        });
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cached-decorator-test.js","sourceRoot":"","sources":["../../../../../packages/@glimmer/tracking/test/cached-decorator-test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/explicit-function-return-type */\nconst { test } = QUnit;\n\nimport { DEBUG } from '@glimmer/env';\nimport { tracked, cached } from '@norith/glimmer-tracking';\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';\n\nQUnit.module('[@glimmer/tracking] @cached Decorators');\n\ntest('it works', function (assert) {\n  class Person {\n    @tracked firstName = 'Jen';\n    @tracked lastName = 'Weber';\n\n    @cached\n    get fullName() {\n      const fullName = `${this.firstName} ${this.lastName}`;\n      assert.step(fullName);\n      return fullName;\n    }\n  }\n\n  const person = new Person();\n  assert.verifySteps([], 'getter is not called after class initialization');\n\n  assert.strictEqual(person.fullName, 'Jen Weber');\n  assert.verifySteps(['Jen Weber'], 'getter was called after property access');\n\n  assert.strictEqual(person.fullName, 'Jen Weber');\n  assert.verifySteps([], 'getter was not called again after repeated property access');\n\n  person.firstName = 'Kenneth';\n  assert.verifySteps([], 'changing a property does not trigger an eager re-computation');\n\n  assert.strictEqual(person.fullName, 'Kenneth Weber');\n  assert.verifySteps(['Kenneth Weber'], 'accessing the property triggers a re-computation');\n\n  assert.strictEqual(person.fullName, 'Kenneth Weber');\n  assert.verifySteps([], 'getter was not called again after repeated property access');\n\n  person.lastName = 'Larsen';\n  assert.verifySteps([], 'changing a property does not trigger an eager re-computation');\n\n  assert.strictEqual(person.fullName, 'Kenneth Larsen');\n  assert.verifySteps(['Kenneth Larsen'], 'accessing the property triggers a re-computation');\n});\n\n// https://github.com/ember-polyfills/ember-cached-decorator-polyfill/issues/7\ntest('it has a separate cache per class instance', function (assert) {\n  class Person {\n    @tracked firstName: string;\n    @tracked lastName: string;\n\n    constructor(firstName: string, lastName: string) {\n      this.firstName = firstName;\n      this.lastName = lastName;\n    }\n\n    @cached\n    get fullName() {\n      const fullName = `${this.firstName} ${this.lastName}`;\n      assert.step(fullName);\n      return fullName;\n    }\n  }\n\n  const jen = new Person('Jen', 'Weber');\n  const chris = new Person('Chris', 'Garrett');\n\n  assert.verifySteps([], 'getter is not called after class initialization');\n\n  assert.strictEqual(jen.fullName, 'Jen Weber');\n  assert.verifySteps(['Jen Weber'], 'getter was called after property access');\n\n  assert.strictEqual(jen.fullName, 'Jen Weber');\n  assert.verifySteps([], 'getter was not called again after repeated property access');\n\n  assert.strictEqual(chris.fullName, 'Chris Garrett', 'other instance has a different value');\n  assert.verifySteps(['Chris Garrett'], 'getter was called after property access');\n\n  assert.strictEqual(chris.fullName, 'Chris Garrett');\n  assert.verifySteps([], 'getter was not called again after repeated property access');\n\n  chris.lastName = 'Manson';\n  assert.verifySteps([], 'changing a property does not trigger an eager re-computation');\n\n  assert.strictEqual(jen.fullName, 'Jen Weber', 'other instance is unaffected');\n  assert.verifySteps([], 'getter was not called again after repeated property access');\n\n  assert.strictEqual(chris.fullName, 'Chris Manson');\n  assert.verifySteps(['Chris Manson'], 'getter was called after property access');\n\n  assert.strictEqual(jen.fullName, 'Jen Weber', 'other instance is unaffected');\n  assert.verifySteps([], 'getter was not called again after repeated property access');\n});\n\n[\n  ['Babel', BabelFixtures],\n  ['TypeScript', TSFixtures],\n].forEach(([compiler, F]) => {\n  QUnit.module(`[@glimmer/tracking] Cached Property Decorators with ${compiler}`);\n\n  if (DEBUG) {\n    test('Cached decorator on a property throws an error', (assert) => {\n      assert.throws(F.createClassWithCachedProperty);\n    });\n\n    test('Cached decorator with a setter throws an error', (assert) => {\n      assert.throws(F.createClassWithCachedSetter);\n    });\n\n    test('Cached decorator with arguments throws an error', function (assert) {\n      assert.throws(\n        F.createClassWithCachedDependentKeys,\n        /@cached\\('firstName', 'lastName'\\)/,\n        'the correct error is thrown'\n      );\n    });\n\n    test('Using @cached as a decorator factory throws an error', function (assert) {\n      assert.throws(\n        F.createClassWithCachedAsDecoratorFactory,\n        /@cached\\(\\)/,\n        'The correct error is thrown'\n      );\n    });\n  }\n});\n"]}

package/dist/commonjs/test/fixtures/typescript.d.ts

@@ -0,0 +1,47 @@
+export declare class Tom {
+    firstName: string;
+}
+export declare class Toran {
+    firstName: string;
+    lastName: string;
+}
+declare class FrozenToran {
+    firstName: string;
+    lastName: string;
+}
+export { FrozenToran };
+export declare class PersonWithCount {
+    _firstName: string;
+    _count: number;
+    get firstName(): string;
+    set firstName(value: string);
+}
+export declare class PersonWithSalutation {
+    get salutation(): string;
+    get fullName(): string;
+    set fullName(fullName: string);
+    firstName: string;
+    lastName: string;
+}
+export declare class Contact {
+    email: string;
+    person: PersonForContact;
+    constructor(person: PersonForContact, email: string);
+    get contact(): string;
+}
+export declare class PersonForContact {
+    get salutation(): string;
+    get fullName(): string;
+    set fullName(fullName: string);
+    toString(): string;
+    firstName: string;
+    lastName: string;
+}
+export declare function createClassWithTrackedGetter(): any;
+export declare function createClassWithCachedProperty(): any;
+export declare function createClassWithTrackedSetter(): any;
+export declare function createClassWithCachedSetter(): any;
+export declare function createClassWithTrackedDependentKeys(): any;
+export declare function createClassWithCachedDependentKeys(): any;
+export declare function createClassWithTrackedAsDecoratorFactory(): any;
+export declare function createClassWithCachedAsDecoratorFactory(): any;