@glimmer/tracking/dist/commonjs/es5/src/tracked.js

Glimmer property tracking library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.tracked = undefined;
exports.setPropertyDidChange = setPropertyDidChange;

var _env = require("@glimmer/env");

var _validator = 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 '@glimmer/component';
 * import { tracked } from '@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 '@glimmer/component';
 * import { tracked } from '@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;
 *    }
 *  }
 * ```
 */
var tracked = exports.tracked = function tracked() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  var target = args[0],
      key = args[1],
      descriptor = args[2]; // Error on `@tracked()`, `@tracked(...args)`, and `@tracked get propName()`

  if (_env.DEBUG && typeof target === 'string') throwTrackedWithArgumentsError(args);
  if (_env.DEBUG && target === undefined) throwTrackedWithEmptyArgumentsError();
  if (_env.DEBUG && descriptor && descriptor.get) throwTrackedComputedPropertyError();

  if (descriptor) {
    return descriptorForField(target, key, descriptor);
  } else {
    // 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));
  }
};

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(function (d) {
    return "'" + 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.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.");
  }

  var _trackedData = (0, _validator.trackedData)(key, desc && desc.initializer),
      getter = _trackedData.getter,
      setter = _trackedData.setter;

  return {
    enumerable: true,
    configurable: true,
    get: function get() {
      return getter(this);
    },
    set: function set(newValue) {
      setter(this, newValue);
      propertyDidChange();
    }
  };
}

var propertyDidChange = function propertyDidChange() {};

function setPropertyDidChange(cb) {
  propertyDidChange = cb;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../packages/@glimmer/tracking/src/tracked.ts"],"names":[],"mappings":"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","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 '@glimmer/component';\n * import { tracked } from '@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 '@glimmer/component';\n * import { tracked } from '@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 */\nexport let tracked: PropertyDecorator = (...args: any[]) => {\n  let [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  } else {\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};\n\nfunction throwTrackedComputedPropertyError() {\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: any[]) {\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() {\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 */\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): DecoratorPropertyDescriptor {\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  let { getter, setter } = trackedData<T, K>(key, desc && desc.initializer);\n\n  return {\n    enumerable: true,\n    configurable: true,\n\n    get(this: T): any {\n      return getter(this);\n    },\n\n    set(this: T, newValue: any): void {\n      setter(this, newValue);\n      propertyDidChange();\n    },\n  };\n}\n\nlet propertyDidChange = function () {};\n\nexport function setPropertyDidChange(cb: () => void) {\n  propertyDidChange = cb;\n}\n"],"sourceRoot":""}