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

Glimmer property tracking library

import { DEBUG } from '@glimmer/env';
import { trackedData } from '@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;
 *    }
 *  }
 * ```
 */

export var 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 (DEBUG && typeof target === 'string') throwTrackedWithArgumentsError(args);
  if (DEBUG && target === undefined) throwTrackedWithEmptyArgumentsError();
  if (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 (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 = 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() {};

export function setPropertyDidChange(cb) {
  propertyDidChange = cb;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../packages/@glimmer/tracking/src/tracked.ts"],"names":[],"mappings":"AAAA,SAAS,KAAT,QAAsB,cAAtB;AACA,SAAS,WAAT,QAA4B,oBAA5B;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,OAAO,IAAI,OAAO,GAAsB,SAA7B,OAA6B,GAAmB;AAAA,oCAAf,IAAe;AAAf,IAAA,IAAe;AAAA;;AAAA,MACpD,MADoD,GACzB,IADyB;AAAA,MAC5C,GAD4C,GACzB,IADyB;AAAA,MACvC,UADuC,GACzB,IADyB,KAGzD;;AACA,MAAI,KAAK,IAAI,OAAO,MAAP,KAAkB,QAA/B,EAAyC,8BAA8B,CAAC,IAAD,CAA9B;AACzC,MAAI,KAAK,IAAI,MAAM,KAAK,SAAxB,EAAmC,mCAAmC;AACtE,MAAI,KAAK,IAAI,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,qLAAN;AAGD;;AAED,SAAS,8BAAT,CAAwC,IAAxC,EAAmD;AACjD,QAAM,IAAI,KAAJ,0CAEF,IAAI,CAAC,MAAL,GAAc,CAAd,GAAkB,WAAlB,GAAgC,aAF9B,qBAGW,IAAI,CAChB,GADY,CACR,UAAC,CAAD;AAAA,iBAAW,CAAX;AAAA,GADQ,EAEZ,IAFY,CAGX,IAHW,CAHX,yHAOmH,YAPnH,OAAN;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,KAAK,IAAI,IAAT,KAAkB,IAAI,CAAC,KAAL,IAAc,IAAI,CAAC,GAAnB,IAA0B,IAAI,CAAC,GAAjD,CAAJ,EAA2D;AACzD,UAAM,IAAI,KAAJ,uCACgC,MAAM,CACxC,GADwC,CADtC,oOAAN;AAKD;;AARiC,qBAUT,WAAW,CAAO,GAAP,EAAY,IAAI,IAAI,IAAI,CAAC,WAAzB,CAVF;AAAA,MAU5B,MAV4B,gBAU5B,MAV4B;AAAA,MAUpB,MAVoB,gBAUpB,MAVoB;;AAYlC,SAAO;AACL,IAAA,UAAU,EAAE,IADP;AAEL,IAAA,YAAY,EAAE,IAFT;AAIL,IAAA,GAJK,iBAIF;AACD,aAAO,MAAM,CAAC,IAAD,CAAb;AACD,KANI;AAQL,IAAA,GARK,eAQQ,QARR,EAQqB;AACxB,MAAA,MAAM,CAAC,IAAD,EAAO,QAAP,CAAN;AACA,MAAA,iBAAiB;AAClB;AAXI,GAAP;AAaD;;AAED,IAAI,iBAAiB,GAAG,6BAAA,CAAc,CAAtC;;AAEA,OAAM,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":""}