@glimmer/tracking/dist/commonjs/es2017/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;
 *    }
 *  }
 * ```
 */
let tracked = exports.tracked = (...args) => {
  let [target, key, descriptor] = args; // 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(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.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.`);
  }

  let {
    getter,
    setter
  } = (0, _validator.trackedData)(key, desc && desc.initializer);
  return {
    enumerable: true,
    configurable: true,

    get() {
      return getter(this);
    },

    set(newValue) {
      setter(this, newValue);
      propertyDidChange();
    }

  };
}

let propertyDidChange = function () {};

function setPropertyDidChange(cb) {
  propertyDidChange = cb;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../packages/@glimmer/tracking/src/tracked.ts"],"names":[],"mappings":";;;;;;QAmJgB,oB,GAAA,oB;;AAnJhB;;AACA;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDO,IAAI,OAAO,WAAP,OAAO,GAAsB,CAAC,GAAG,IAAJ,KAAmB;AACzD,MAAI,CAAC,MAAD,EAAS,GAAT,EAAc,UAAd,IAA4B,IAAhC,CADyD,CAGzD;;AACA,MAAI,cAAS,OAAO,MAAP,KAAkB,QAA/B,EAAyC,8BAA8B,CAAC,IAAD,CAA9B;AACzC,MAAI,cAAS,MAAM,KAAK,SAAxB,EAAmC,mCAAmC;AACtE,MAAI,cAAS,UAAT,IAAuB,UAAU,CAAC,GAAtC,EAA2C,iCAAiC;;AAE5E,MAAI,UAAJ,EAAgB;AACd,WAAO,kBAAkB,CAAC,MAAD,EAAS,GAAT,EAAc,UAAd,CAAzB;AACD,GAFD,MAEO;AACL;AACA;AACA,IAAA,MAAM,CAAC,cAAP,CAAsB,MAAtB,EAA8B,GAA9B,EAAmC,kBAAkB,CAAC,MAAD,EAAS,GAAT,CAArD;AACD;AACF,CAfM;;AAiBP,SAAS,iCAAT,GAA0C;AACxC,QAAM,IAAI,KAAJ,CACJ,mLADI,CAAN;AAGD;;AAED,SAAS,8BAAT,CAAwC,IAAxC,EAAmD;AACjD,QAAM,IAAI,KAAJ,CACJ,sCACE,IAAI,CAAC,MAAL,GAAc,CAAd,GAAkB,WAAlB,GAAgC,aAClC,eAAe,IAAI,CAChB,GADY,CACP,CAAD,IAAO,IAAI,CAAC,GADJ,EAEZ,IAFY,CAGX,IAHW,CAIZ,oHAAoH,YAAY,GAP/H,CAAN;AASD;;AAED,SAAS,mCAAT,GAA4C;AAC1C,QAAM,IAAI,KAAJ,CACJ,iIADI,CAAN;AAGD;;AAiBD,SAAS,kBAAT,CACE,OADF,EAEE,GAFF,EAGE,IAHF,EAGoC;AAElC,MAAI,cAAS,IAAT,KAAkB,IAAI,CAAC,KAAL,IAAc,IAAI,CAAC,GAAnB,IAA0B,IAAI,CAAC,GAAjD,CAAJ,EAA2D;AACzD,UAAM,IAAI,KAAJ,CACJ,oCAAoC,MAAM,CACxC,GADwC,CAEzC,gOAHG,CAAN;AAKD;;AAED,MAAI;AAAE,IAAA,MAAF;AAAU,IAAA;AAAV,MAAqB,4BAAkB,GAAlB,EAAuB,IAAI,IAAI,IAAI,CAAC,WAApC,CAAzB;AAEA,SAAO;AACL,IAAA,UAAU,EAAE,IADP;AAEL,IAAA,YAAY,EAAE,IAFT;;AAIL,IAAA,GAAG,GAAA;AACD,aAAO,MAAM,CAAC,IAAD,CAAb;AACD,KANI;;AAQL,IAAA,GAAG,CAAU,QAAV,EAAuB;AACxB,MAAA,MAAM,CAAC,IAAD,EAAO,QAAP,CAAN;AACA,MAAA,iBAAiB;AAClB;;AAXI,GAAP;AAaD;;AAED,IAAI,iBAAiB,GAAG,YAAA,CAAc,CAAtC;;AAEM,SAAU,oBAAV,CAA+B,EAA/B,EAA6C;AACjD,EAAA,iBAAiB,GAAG,EAApB;AACD","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":""}