ha

Author: NullVoxPopuli

packages/@ember/object/index.ts

@@ -1,311 +0,0 @@
-import { assert } from '@ember/debug';
-import { ENV } from '@ember/-internals/environment';
-import type { ElementDescriptor, ExtendedMethodDecorator } from '@ember/-internals/metal';
-import {
-  isElementDescriptor,
-  expandProperties,
-  setClassicDecorator,
-} from '@ember/-internals/metal';
-import { getFactoryFor } from '@ember/-internals/container';
-import { setObservers } from '@ember/-internals/utils';
-import type { AnyFn } from '@ember/-internals/utility-types';
-import CoreObject from '@ember/object/core';
-import Observable from '@ember/object/observable';
-
-export {
-  notifyPropertyChange,
-  defineProperty,
-  get,
-  set,
-  getProperties,
-  setProperties,
-  computed,
-  trySet,
-} from '@ember/-internals/metal';
-
-/**
-@module @ember/object
-*/
-
-/**
-  `EmberObject` is the main base class for all Ember objects. It is a subclass
-  of `CoreObject` with the `Observable` mixin applied. For details,
-  see the documentation for each of these.
-
-  @class EmberObject
-  @extends CoreObject
-  @uses Observable
-  @public
-*/
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-interface EmberObject extends Observable {}
-class EmberObject extends CoreObject.extend(Observable) {
-  get _debugContainerKey() {
-    let factory = getFactoryFor(this);
-    return factory !== undefined && factory.fullName;
-  }
-}
-
-export default EmberObject;
-
-/**
-  Decorator that turns the target function into an Action which can be accessed
-  directly by reference.
-
-  ```js
-  import Component from '@ember/component';
-  import { tracked } from '@glimmer/tracking';
-  import { action } from '@ember/object';
-
-  export default class Tooltip extends Component {
-    @tracked isShowing = false;
-
-    @action
-    toggleShowing() {
-      this.isShowing = !this.isShowing;
-    }
-  }
-  ```
-  ```hbs
-  <!-- template.hbs -->
-  <button {{on "click" this.toggleShowing}}>Show tooltip</button>
-
-  {{#if isShowing}}
-    <div class="tooltip">
-      I'm a tooltip!
-    </div>
-  {{/if}}
-  ```
-
-  It also binds the function directly to the instance, so it can be used in any
-  context and will correctly refer to the class it came from:
-
-  ```js
-  import Component from '@ember/component';
-  import { tracked } from '@glimmer/tracking';
-  import { action } from '@ember/object';
-
-  export default class Tooltip extends Component {
-    constructor() {
-      super(...arguments);
-
-      // this.toggleShowing is still bound correctly when added to
-      // the event listener
-      document.addEventListener('click', this.toggleShowing);
-    }
-
-    @tracked isShowing = false;
-
-    @action
-    toggleShowing() {
-      this.isShowing = !this.isShowing;
-    }
-  }
-  ```
-
-  @public
-  @method action
-  @for @ember/object
-  @static
-  @param {Function|undefined} callback The function to turn into an action,
-                                       when used in classic classes
-  @return {PropertyDecorator} property decorator instance
-*/
-
-const BINDINGS_MAP = new WeakMap();
-
-interface HasProto {
-  constructor: {
-    proto(): void;
-  };
-}
-
-function hasProto(obj: unknown): obj is HasProto {
-  return (
-    obj != null &&
-    (obj as any).constructor !== undefined &&
-    typeof ((obj as any).constructor as any).proto === 'function'
-  );
-}
-
-interface HasActions {
-  actions: Record<string | symbol, unknown>;
-}
-
-function setupAction(
-  target: Partial<HasActions>,
-  key: string | symbol,
-  actionFn: Function
-): TypedPropertyDescriptor<unknown> {
-  if (hasProto(target)) {
-    target.constructor.proto();
-  }
-
-  if (!Object.prototype.hasOwnProperty.call(target, 'actions')) {
-    let parentActions = target.actions;
-    // we need to assign because of the way mixins copy actions down when inheriting
-    target.actions = parentActions ? Object.assign({}, parentActions) : {};
-  }
-
-  assert("[BUG] Somehow the target doesn't have actions!", target.actions != null);
-
-  target.actions[key] = actionFn;
-
-  return {
-    get() {
-      let bindings = BINDINGS_MAP.get(this);
-
-      if (bindings === undefined) {
-        bindings = new Map();
-        BINDINGS_MAP.set(this, bindings);
-      }
-
-      let fn = bindings.get(actionFn);
-
-      if (fn === undefined) {
-        fn = actionFn.bind(this);
-        bindings.set(actionFn, fn);
-      }
-
-      return fn;
-    },
-  };
-}
-
-export function action(
-  target: ElementDescriptor[0],
-  key: ElementDescriptor[1],
-  desc: ElementDescriptor[2]
-): PropertyDescriptor;
-export function action(desc: PropertyDescriptor): ExtendedMethodDecorator;
-export function action(
-  ...args: ElementDescriptor | [PropertyDescriptor]
-): PropertyDescriptor | ExtendedMethodDecorator {
-  let actionFn: object | Function;
-
-  if (!isElementDescriptor(args)) {
-    actionFn = args[0];
-
-    let decorator: ExtendedMethodDecorator = function (
-      target,
-      key,
-      _desc,
-      _meta,
-      isClassicDecorator
-    ) {
-      assert(
-        'The @action decorator may only be passed a method when used in classic classes. You should decorate methods directly in native classes',
-        isClassicDecorator
-      );
-
-      assert(
-        'The action() decorator must be passed a method when used in classic classes',
-        typeof actionFn === 'function'
-      );
-
-      return setupAction(target, key, actionFn);
-    };
-
-    setClassicDecorator(decorator);
-
-    return decorator;
-  }
-
-  let [target, key, desc] = args;
-
-  actionFn = desc?.value;
-
-  assert(
-    'The @action decorator must be applied to methods when used in native classes',
-    typeof actionFn === 'function'
-  );
-
-  // SAFETY: TS types are weird with decorators. This should work.
-  return setupAction(target, key, actionFn);
-}
-
-// SAFETY: TS types are weird with decorators. This should work.
-setClassicDecorator(action as ExtendedMethodDecorator);
-
-// ..........................................................
-// OBSERVER HELPER
-//
-
-type ObserverDefinition<T extends AnyFn> = {
-  dependentKeys: string[];
-  fn: T;
-  sync: boolean;
-};
-
-/**
-  Specify a method that observes property changes.
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { observer } from '@ember/object';
-
-  export default EmberObject.extend({
-    valueObserver: observer('value', function() {
-      // Executes whenever the "value" property changes
-    })
-  });
-  ```
-
-  Also available as `Function.prototype.observes` if prototype extensions are
-  enabled.
-
-  @method observer
-  @for @ember/object
-  @param {String} propertyNames*
-  @param {Function} func
-  @return func
-  @public
-  @static
-*/
-export function observer<T extends AnyFn>(
-  ...args:
-    | [propertyName: string, ...additionalPropertyNames: string[], func: T]
-    | [ObserverDefinition<T>]
-): T {
-  let funcOrDef = args.pop();
-
-  assert(
-    'observer must be provided a function or an observer definition',
-    typeof funcOrDef === 'function' || (typeof funcOrDef === 'object' && funcOrDef !== null)
-  );
-
-  let func: T;
-  let dependentKeys: string[];
-  let sync: boolean;
-
-  if (typeof funcOrDef === 'function') {
-    func = funcOrDef;
-    dependentKeys = args as string[];
-    sync = !ENV._DEFAULT_ASYNC_OBSERVERS;
-  } else {
-    func = funcOrDef.fn;
-    dependentKeys = funcOrDef.dependentKeys;
-    sync = funcOrDef.sync;
-  }
-
-  assert('observer called without a function', typeof func === 'function');
-  assert(
-    'observer called without valid path',
-    Array.isArray(dependentKeys) &&
-      dependentKeys.length > 0 &&
-      dependentKeys.every((p) => typeof p === 'string' && Boolean(p.length))
-  );
-  assert('observer called without sync', typeof sync === 'boolean');
-
-  let paths: string[] = [];
-
-  for (let dependentKey of dependentKeys) {
-    expandProperties(dependentKey, (path: string) => paths.push(path));
-  }
-
-  setObservers(func as Function, {
-    paths,
-    sync,
-  });
-  return func;
-}