discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-runtime/lib/copy.js

@@ -1,106 +0,0 @@
-import { assert, deprecate } from '@ember/debug';
-import EmberObject from './system/object';
-import Copyable from './mixins/copyable';
-
-/**
- @module @ember/object
-*/
-function _copy(obj, deep, seen, copies) {
-  // primitive data types are immutable, just return them.
-  if (typeof obj !== 'object' || obj === null) {
-    return obj;
-  }
-
-  let ret, loc;
-
-  // avoid cyclical loops
-  if (deep && (loc = seen.indexOf(obj)) >= 0) {
-    return copies[loc];
-  }
-
-  // IMPORTANT: this specific test will detect a native array only. Any other
-  // object will need to implement Copyable.
-  if (Array.isArray(obj)) {
-    ret = obj.slice();
-
-    if (deep) {
-      loc = ret.length;
-
-      while (--loc >= 0) {
-        ret[loc] = _copy(ret[loc], deep, seen, copies);
-      }
-    }
-  } else if (Copyable.detect(obj)) {
-    ret = obj.copy(deep, seen, copies);
-  } else if (obj instanceof Date) {
-    ret = new Date(obj.getTime());
-  } else {
-    assert(
-      'Cannot clone an EmberObject that does not implement Copyable',
-      !(obj instanceof EmberObject) || Copyable.detect(obj)
-    );
-
-    ret = {};
-    let key;
-    for (key in obj) {
-      // support Null prototype
-      if (!Object.prototype.hasOwnProperty.call(obj, key)) {
-        continue;
-      }
-
-      // Prevents browsers that don't respect non-enumerability from
-      // copying internal Ember properties
-      if (key.substring(0, 2) === '__') {
-        continue;
-      }
-
-      ret[key] = deep ? _copy(obj[key], deep, seen, copies) : obj[key];
-    }
-  }
-
-  if (deep) {
-    seen.push(obj);
-    copies.push(ret);
-  }
-
-  return ret;
-}
-
-/**
-  Creates a shallow copy of the passed object. A deep copy of the object is
-  returned if the optional `deep` argument is `true`.
-
-  If the passed object implements the `Copyable` interface, then this
-  function will delegate to the object's `copy()` method and return the
-  result. See `Copyable` for further details.
-
-  For primitive values (which are immutable in JavaScript), the passed object
-  is simply returned.
-
-  @method copy
-  @deprecated Use 'ember-copy' addon instead
-  @static
-  @for @ember/object/internals
-  @param {Object} obj The object to clone
-  @param {Boolean} [deep=false] If true, a deep copy of the object is made.
-  @return {Object} The copied object
-  @public
-*/
-export default function copy(obj, deep) {
-  deprecate('Use ember-copy addon instead of copy method and Copyable mixin.', false, {
-    id: 'ember-runtime.deprecate-copy-copyable',
-    until: '4.0.0',
-    url: 'https://emberjs.com/deprecations/v3.x/#toc_ember-runtime-deprecate-copy-copyable',
-  });
-
-  // fast paths
-  if ('object' !== typeof obj || obj === null) {
-    return obj; // can't copy primitives
-  }
-
-  if (!Array.isArray(obj) && Copyable.detect(obj)) {
-    return obj.copy(deep);
-  }
-
-  return _copy(obj, deep, deep ? [] : null, deep ? [] : null);
-}

data/dist/es/ember-runtime/lib/ext/function.js

@@ -1,154 +0,0 @@
-/**
-@module ember
-*/
-
-import { ENV } from 'ember-environment';
-import { on, computed, observer } from 'ember-metal';
-
-if (ENV.EXTEND_PROTOTYPES.Function) {
-  Object.defineProperties(Function.prototype, {
-    /**
-      The `property` extension of Javascript's Function prototype is available
-      when `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Function` is
-      `true`, which is the default.
-
-      Computed properties allow you to treat a function like a property:
-
-      ```app/utils/president.js
-      import EmberObject from '@ember/object';
-
-      export default EmberObject.extend({
-        firstName: '',
-        lastName:  '',
-
-        fullName: function() {
-          return this.get('firstName') + ' ' + this.get('lastName');
-        }.property() // Call this flag to mark the function as a property
-      });
-      ```
-
-      ```javascript
-      let president = President.create({
-        firstName: 'Barack',
-        lastName: 'Obama'
-      });
-
-      president.get('fullName'); // 'Barack Obama'
-      ```
-
-      Treating a function like a property is useful because they can work with
-      bindings, just like any other property.
-
-      Many computed properties have dependencies on other properties. For
-      example, in the above example, the `fullName` property depends on
-      `firstName` and `lastName` to determine its value. You can tell Ember
-      about these dependencies like this:
-
-      ```app/utils/president.js
-      import EmberObject from '@ember/object';
-
-      export default EmberObject.extend({
-        firstName: '',
-        lastName:  '',
-
-        fullName: function() {
-          return this.get('firstName') + ' ' + this.get('lastName');
-
-          // Tell Ember.js that this computed property depends on firstName
-          // and lastName
-        }.property('firstName', 'lastName')
-      });
-      ```
-
-      Make sure you list these dependencies so Ember knows when to update
-      bindings that connect to a computed property. Changing a dependency
-      will not immediately trigger an update of the computed property, but
-      will instead clear the cache so that it is updated when the next `get`
-      is called on the property.
-
-      See [ComputedProperty](/api/ember/release/classes/ComputedProperty), [@ember/object/computed](/api/ember/release/classes/@ember%2Fobject%2Fcomputed).
-
-      @method property
-      @for Function
-      @public
-    */
-    property: {
-      configurable: true,
-      enumerable: false,
-      writable: true,
-      value: function() {
-        return computed(...arguments, this);
-      },
-    },
-
-    /**
-      The `observes` extension of Javascript's Function prototype is available
-      when `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Function` is
-      true, which is the default.
-
-      You can observe property changes simply by adding the `observes`
-      call to the end of your method declarations in classes that you write.
-      For example:
-
-      ```javascript
-      import EmberObject from '@ember/object';
-
-      EmberObject.extend({
-        valueObserver: function() {
-          // Executes whenever the "value" property changes
-        }.observes('value')
-      });
-      ```
-
-      In the future this method may become asynchronous.
-
-      See `observer`.
-
-      @method observes
-      @for Function
-      @public
-    */
-    observes: {
-      configurable: true,
-      enumerable: false,
-      writable: true,
-      value: function() {
-        return observer(...arguments, this);
-      },
-    },
-
-    /**
-      The `on` extension of Javascript's Function prototype is available
-      when `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Function` is
-      true, which is the default.
-
-      You can listen for events simply by adding the `on` call to the end of
-      your method declarations in classes or mixins that you write. For example:
-
-      ```javascript
-      import Mixin from '@ember/mixin';
-
-      Mixin.create({
-        doSomethingWithElement: function() {
-          // Executes whenever the "didInsertElement" event fires
-        }.on('didInsertElement')
-      });
-      ```
-
-      See `@ember/object/evented/on`.
-
-      @method on
-      @for Function
-      @public
-    */
-
-    on: {
-      configurable: true,
-      enumerable: false,
-      writable: true,
-      value: function() {
-        return on(...arguments, this);
-      },
-    },
-  });
-}

data/dist/es/ember-runtime/lib/ext/rsvp.js

@@ -1,59 +0,0 @@
-import * as RSVP from 'rsvp';
-import { backburner, _rsvpErrorQueue } from '@ember/runloop';
-import { getDispatchOverride } from 'ember-error-handling';
-import { assert } from '@ember/debug';
-
-RSVP.configure('async', (callback, promise) => {
-  backburner.schedule('actions', null, callback, promise);
-});
-
-RSVP.configure('after', cb => {
-  backburner.schedule(_rsvpErrorQueue, null, cb);
-});
-
-RSVP.on('error', onerrorDefault);
-
-export function onerrorDefault(reason) {
-  let error = errorFor(reason);
-  if (error) {
-    let overrideDispatch = getDispatchOverride();
-    if (overrideDispatch) {
-      overrideDispatch(error);
-    } else {
-      throw error;
-    }
-  }
-}
-
-function errorFor(reason) {
-  if (!reason) return;
-
-  if (reason.errorThrown) {
-    return unwrapErrorThrown(reason);
-  }
-
-  if (reason.name === 'UnrecognizedURLError') {
-    assert(`The URL '${reason.message}' did not match any routes in your application`, false);
-    return;
-  }
-
-  if (reason.name === 'TransitionAborted') {
-    return;
-  }
-
-  return reason;
-}
-
-function unwrapErrorThrown(reason) {
-  let error = reason.errorThrown;
-  if (typeof error === 'string') {
-    error = new Error(error);
-  }
-  Object.defineProperty(error, '__reason_with_error_thrown__', {
-    value: reason,
-    enumerable: false,
-  });
-  return error;
-}
-
-export default RSVP;

data/dist/es/ember-runtime/lib/is-equal.js

@@ -1,60 +0,0 @@
-/**
- @module @ember/utils
-*/
-/**
-  Compares two objects, returning true if they are equal.
-
-  ```javascript
-  import { isEqual } from '@ember/utils';
-
-  isEqual('hello', 'hello');                   // true
-  isEqual(1, 2);                               // false
-  ```
-
-  `isEqual` is a more specific comparison than a triple equal comparison.
-  It will call the `isEqual` instance method on the objects being
-  compared, allowing finer control over when objects should be considered
-  equal to each other.
-
-  ```javascript
-  import { isEqual } from '@ember/utils';
-  import EmberObject from '@ember/object';
-
-  let Person = EmberObject.extend({
-    isEqual(other) { return this.ssn == other.ssn; }
-  });
-
-  let personA = Person.create({name: 'Muhammad Ali', ssn: '123-45-6789'});
-  let personB = Person.create({name: 'Cassius Clay', ssn: '123-45-6789'});
-
-  isEqual(personA, personB); // true
-  ```
-
-  Due to the expense of array comparisons, collections will never be equal to
-  each other even if each of their items are equal to each other.
-
-  ```javascript
-  import { isEqual } from '@ember/utils';
-
-  isEqual([4, 2], [4, 2]);                     // false
-  ```
-
-  @method isEqual
-  @for @ember/utils
-  @static
-  @param {Object} a first object to compare
-  @param {Object} b second object to compare
-  @return {Boolean}
-  @public
-*/
-export default function isEqual(a, b) {
-  if (a && typeof a.isEqual === 'function') {
-    return a.isEqual(b);
-  }
-
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime();
-  }
-
-  return a === b;
-}

data/dist/es/ember-runtime/lib/mixins/-proxy.js

@@ -1,109 +0,0 @@
-/**
-@module ember
-*/
-
-import { combine, CONSTANT_TAG, DirtyableTag, UpdatableTag } from '@glimmer/reference';
-import { meta } from 'ember-meta';
-import {
-  get,
-  set,
-  addObserver,
-  removeObserver,
-  notifyPropertyChange,
-  defineProperty,
-  Mixin,
-  tagFor,
-  computed,
-} from 'ember-metal';
-import { setProxy } from 'ember-utils';
-import { assert } from '@ember/debug';
-
-function contentPropertyDidChange(content, contentKey) {
-  let key = contentKey.slice(8); // remove "content."
-  if (key in this) {
-    return;
-  } // if shadowed in proxy
-  notifyPropertyChange(this, key);
-}
-
-export function contentFor(proxy, m) {
-  let content = get(proxy, 'content');
-  let tag = (m === undefined ? meta(proxy) : m).readableTag();
-  if (tag !== undefined) {
-    tag.inner.second.inner.update(tagFor(content));
-  }
-  return content;
-}
-
-/**
-  `Ember.ProxyMixin` forwards all properties not defined by the proxy itself
-  to a proxied `content` object.  See ObjectProxy for more details.
-
-  @class ProxyMixin
-  @namespace Ember
-  @private
-*/
-export default Mixin.create({
-  /**
-    The object whose properties will be forwarded.
-
-    @property content
-    @type EmberObject
-    @default null
-    @private
-  */
-  content: null,
-
-  init() {
-    this._super(...arguments);
-    setProxy(this);
-    let m = meta(this);
-    m.writableTag(() => combine([DirtyableTag.create(), UpdatableTag.create(CONSTANT_TAG)]));
-  },
-
-  willDestroy() {
-    this.set('content', null);
-    this._super(...arguments);
-  },
-
-  isTruthy: computed('content', function() {
-    return !!get(this, 'content');
-  }),
-
-  willWatchProperty(key) {
-    let contentKey = `content.${key}`;
-    addObserver(this, contentKey, null, contentPropertyDidChange);
-  },
-
-  didUnwatchProperty(key) {
-    let contentKey = `content.${key}`;
-    removeObserver(this, contentKey, null, contentPropertyDidChange);
-  },
-
-  unknownProperty(key) {
-    let content = contentFor(this);
-    if (content) {
-      return get(content, key);
-    }
-  },
-
-  setUnknownProperty(key, value) {
-    let m = meta(this);
-
-    if (m.proto === this) {
-      // if marked as prototype then just defineProperty
-      // rather than delegate
-      defineProperty(this, key, null, value);
-      return value;
-    }
-
-    let content = contentFor(this, m);
-
-    assert(
-      `Cannot delegate set('${key}', ${value}) to the \'content\' property of object proxy ${this}: its 'content' is undefined.`,
-      content
-    );
-
-    return set(content, key, value);
-  },
-});