discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-metal/lib/computed_cache.js

@@ -1,58 +0,0 @@
-import { EMBER_METAL_TRACKED_PROPERTIES } from '@ember/canary-features';
-const COMPUTED_PROPERTY_CACHED_VALUES = new WeakMap();
-const COMPUTED_PROPERTY_LAST_REVISION = EMBER_METAL_TRACKED_PROPERTIES
-    ? new WeakMap()
-    : undefined;
-/**
-  Returns the cached value for a property, if one exists.
-  This can be useful for peeking at the value of a computed
-  property that is generated lazily, without accidentally causing
-  it to be created.
-
-  @method cacheFor
-  @static
-  @for @ember/object/internals
-  @param {Object} obj the object whose property you want to check
-  @param {String} key the name of the property whose cached value you want
-    to return
-  @return {Object} the cached value
-  @public
-*/
-export function getCacheFor(obj) {
-    let cache = COMPUTED_PROPERTY_CACHED_VALUES.get(obj);
-    if (cache === undefined) {
-        cache = new Map();
-        if (EMBER_METAL_TRACKED_PROPERTIES) {
-            COMPUTED_PROPERTY_LAST_REVISION.set(obj, new Map());
-        }
-        COMPUTED_PROPERTY_CACHED_VALUES.set(obj, cache);
-    }
-    return cache;
-}
-export function getCachedValueFor(obj, key) {
-    let cache = COMPUTED_PROPERTY_CACHED_VALUES.get(obj);
-    if (cache !== undefined) {
-        return cache.get(key);
-    }
-}
-export let setLastRevisionFor;
-export let getLastRevisionFor;
-if (EMBER_METAL_TRACKED_PROPERTIES) {
-    setLastRevisionFor = (obj, key, revision) => {
-        let lastRevision = COMPUTED_PROPERTY_LAST_REVISION.get(obj);
-        lastRevision.set(key, revision);
-    };
-    getLastRevisionFor = (obj, key) => {
-        let cache = COMPUTED_PROPERTY_LAST_REVISION.get(obj);
-        if (cache === undefined) {
-            return 0;
-        }
-        else {
-            let revision = cache.get(key);
-            return revision === undefined ? 0 : revision;
-        }
-    };
-}
-export function peekCacheFor(obj) {
-    return COMPUTED_PROPERTY_CACHED_VALUES.get(obj);
-}

data/dist/es/ember-metal/lib/dependent_keys.js

@@ -1,34 +0,0 @@
-import { unwatch, watch } from './watching';
-// ..........................................................
-// DEPENDENT KEYS
-//
-export function addDependentKeys(desc, obj, keyName, meta) {
-    // the descriptor has a list of dependent keys, so
-    // add all of its dependent keys.
-    let depKeys = desc._dependentKeys;
-    if (depKeys === null || depKeys === undefined) {
-        return;
-    }
-    for (let idx = 0; idx < depKeys.length; idx++) {
-        let depKey = depKeys[idx];
-        // Increment the number of times depKey depends on keyName.
-        meta.writeDeps(depKey, keyName, meta.peekDeps(depKey, keyName) + 1);
-        // Watch the depKey
-        watch(obj, depKey, meta);
-    }
-}
-export function removeDependentKeys(desc, obj, keyName, meta) {
-    // the descriptor has a list of dependent keys, so
-    // remove all of its dependent keys.
-    let depKeys = desc._dependentKeys;
-    if (depKeys === null || depKeys === undefined) {
-        return;
-    }
-    for (let idx = 0; idx < depKeys.length; idx++) {
-        let depKey = depKeys[idx];
-        // Decrement the number of times depKey depends on keyName.
-        meta.writeDeps(depKey, keyName, meta.peekDeps(depKey, keyName) - 1);
-        // Unwatch the depKey
-        unwatch(obj, depKey, meta);
-    }
-}

data/dist/es/ember-metal/lib/deprecate_property.js

@@ -1,34 +0,0 @@
-/**
-@module ember
-*/
-import { deprecate } from '@ember/debug';
-import { get } from './property_get';
-import { set } from './property_set';
-/**
-  Used internally to allow changing properties in a backwards compatible way, and print a helpful
-  deprecation warning.
-
-  @method deprecateProperty
-  @param {Object} object The object to add the deprecated property to.
-  @param {String} deprecatedKey The property to add (and print deprecation warnings upon accessing).
-  @param {String} newKey The property that will be aliased.
-  @private
-  @since 1.7.0
-*/
-export function deprecateProperty(object, deprecatedKey, newKey, options) {
-    function _deprecate() {
-        deprecate(`Usage of \`${deprecatedKey}\` is deprecated, use \`${newKey}\` instead.`, false, options);
-    }
-    Object.defineProperty(object, deprecatedKey, {
-        configurable: true,
-        enumerable: false,
-        set(value) {
-            _deprecate();
-            set(this, newKey, value);
-        },
-        get() {
-            _deprecate();
-            return get(this, newKey);
-        },
-    });
-}

data/dist/es/ember-metal/lib/descriptor.js

@@ -1,28 +0,0 @@
-import { Descriptor as EmberDescriptor } from './properties';
-export default function descriptor(desc) {
-    return new Descriptor(desc);
-}
-/**
-  A wrapper for a native ES5 descriptor. In an ideal world, we wouldn't need
-  this at all, however, the way we currently flatten/merge our mixins require
-  a special value to denote a descriptor.
-
-  @class Descriptor
-  @private
-*/
-class Descriptor extends EmberDescriptor {
-    constructor(desc) {
-        super();
-        this.desc = desc;
-        this.enumerable = desc.enumerable !== false;
-    }
-    setup(obj, key) {
-        Object.defineProperty(obj, key, this.desc);
-    }
-    get(obj, key) {
-        return obj[key];
-    }
-    set(obj, key, value) {
-        return (obj[key] = value);
-    }
-}

data/dist/es/ember-metal/lib/each_proxy.js

@@ -1,106 +0,0 @@
-import { assert } from '@ember/debug';
-import { meta, peekMeta } from 'ember-meta';
-import { objectAt } from './array';
-import { EACH_PROXIES } from './each_proxy_events';
-import { addObserver, removeObserver } from './observer';
-import { notifyPropertyChange } from './property_events';
-export function eachProxyFor(array) {
-    let eachProxy = EACH_PROXIES.get(array);
-    if (eachProxy === undefined) {
-        eachProxy = new EachProxy(array);
-        EACH_PROXIES.set(array, eachProxy);
-    }
-    return eachProxy;
-}
-class EachProxy {
-    constructor(content) {
-        this._content = content;
-        this._keys = undefined;
-        meta(this);
-    }
-    // ..........................................................
-    // ARRAY CHANGES
-    // Invokes whenever the content array itself changes.
-    arrayWillChange(content, idx, removedCnt /*, addedCnt */) {
-        // eslint-disable-line no-unused-vars
-        let keys = this._keys;
-        if (!keys) {
-            return;
-        }
-        let lim = removedCnt > 0 ? idx + removedCnt : -1;
-        if (lim > 0) {
-            for (let key in keys) {
-                removeObserverForContentKey(content, key, this, idx, lim);
-            }
-        }
-    }
-    arrayDidChange(content, idx, _removedCnt, addedCnt) {
-        let keys = this._keys;
-        if (!keys) {
-            return;
-        }
-        let lim = addedCnt > 0 ? idx + addedCnt : -1;
-        let meta = peekMeta(this);
-        for (let key in keys) {
-            if (lim > 0) {
-                addObserverForContentKey(content, key, this, idx, lim);
-            }
-            notifyPropertyChange(this, key, meta);
-        }
-    }
-    // ..........................................................
-    // LISTEN FOR NEW OBSERVERS AND OTHER EVENT LISTENERS
-    // Start monitoring keys based on who is listening...
-    willWatchProperty(property) {
-        this.beginObservingContentKey(property);
-    }
-    didUnwatchProperty(property) {
-        this.stopObservingContentKey(property);
-    }
-    // ..........................................................
-    // CONTENT KEY OBSERVING
-    // Actual watch keys on the source content.
-    beginObservingContentKey(keyName) {
-        let keys = this._keys;
-        if (keys === undefined) {
-            keys = this._keys = Object.create(null);
-        }
-        if (!keys[keyName]) {
-            keys[keyName] = 1;
-            let content = this._content;
-            let len = content.length;
-            addObserverForContentKey(content, keyName, this, 0, len);
-        }
-        else {
-            keys[keyName]++;
-        }
-    }
-    stopObservingContentKey(keyName) {
-        let keys = this._keys;
-        if (keys !== undefined && keys[keyName] > 0 && --keys[keyName] <= 0) {
-            let content = this._content;
-            let len = content.length;
-            removeObserverForContentKey(content, keyName, this, 0, len);
-        }
-    }
-    contentKeyDidChange(_obj, keyName) {
-        notifyPropertyChange(this, keyName);
-    }
-}
-function addObserverForContentKey(content, keyName, proxy, idx, loc) {
-    while (--loc >= idx) {
-        let item = objectAt(content, loc);
-        if (item) {
-            assert(`When using @each to observe the array \`${content.toString()}\`, the array must return an object`, typeof item === 'object');
-            addObserver(item, keyName, proxy, 'contentKeyDidChange');
-        }
-    }
-}
-function removeObserverForContentKey(content, keyName, proxy, idx, loc) {
-    while (--loc >= idx) {
-        let item = objectAt(content, loc);
-        if (item) {
-            removeObserver(item, keyName, proxy, 'contentKeyDidChange');
-        }
-    }
-}

data/dist/es/ember-metal/lib/each_proxy_events.js

@@ -1,13 +0,0 @@
-export const EACH_PROXIES = new WeakMap();
-export function eachProxyArrayWillChange(array, idx, removedCnt, addedCnt) {
-    let eachProxy = EACH_PROXIES.get(array);
-    if (eachProxy !== undefined) {
-        eachProxy.arrayWillChange(array, idx, removedCnt, addedCnt);
-    }
-}
-export function eachProxyArrayDidChange(array, idx, removedCnt, addedCnt) {
-    let eachProxy = EACH_PROXIES.get(array);
-    if (eachProxy !== undefined) {
-        eachProxy.arrayDidChange(array, idx, removedCnt, addedCnt);
-    }
-}

data/dist/es/ember-metal/lib/events.js

@@ -1,174 +0,0 @@
-/**
-@module @ember/object
-*/
-import { assert, deprecate } from '@ember/debug';
-import { DID_INIT_ATTRS } from '@ember/deprecated-features';
-import { ENV } from 'ember-environment';
-import { meta as metaFor, peekMeta } from 'ember-meta';
-import { setListeners } from 'ember-utils';
-/*
-  The event system uses a series of nested hashes to store listeners on an
-  object. When a listener is registered, or when an event arrives, these
-  hashes are consulted to determine which target and action pair to invoke.
-
-  The hashes are stored in the object's meta hash, and look like this:
-
-      // Object's meta hash
-      {
-        listeners: {       // variable name: `listenerSet`
-          "foo:change": [ // variable name: `actions`
-            target, method, once
-          ]
-        }
-      }
-
-*/
-/**
-  Add an event listener
-
-  @method addListener
-  @static
-  @for @ember/object/events
-  @param obj
-  @param {String} eventName
-  @param {Object|Function} target A target object or a function
-  @param {Function|String} method A function or the name of a function to be called on `target`
-  @param {Boolean} once A flag whether a function should only be called once
-  @public
-*/
-export function addListener(obj, eventName, target, method, once) {
-    assert('You must pass at least an object and event name to addListener', !!obj && !!eventName);
-    if (DID_INIT_ATTRS && ENV._ENABLE_DID_INIT_ATTRS_SUPPORT === true) {
-        deprecate(`didInitAttrs called in ${obj && obj.toString && obj.toString()}.`, eventName !== 'didInitAttrs', {
-            id: 'ember-views.did-init-attrs',
-            until: '3.0.0',
-            url: 'https://emberjs.com/deprecations/v2.x#toc_ember-component-didinitattrs',
-        });
-    }
-    else {
-        assert(`didInitAttrs called in ${obj && obj.toString && obj.toString()} is no longer supported.`, eventName !== 'didInitAttrs');
-    }
-    if (!method && 'function' === typeof target) {
-        method = target;
-        target = null;
-    }
-    metaFor(obj).addToListeners(eventName, target, method, once === true);
-}
-/**
-  Remove an event listener
-
-  Arguments should match those passed to `addListener`.
-
-  @method removeListener
-  @static
-  @for @ember/object/events
-  @param obj
-  @param {String} eventName
-  @param {Object|Function} target A target object or a function
-  @param {Function|String} method A function or the name of a function to be called on `target`
-  @public
-*/
-export function removeListener(obj, eventName, target, method) {
-    assert('You must pass at least an object and event name to removeListener', !!obj && !!eventName);
-    if (!method && 'function' === typeof target) {
-        method = target;
-        target = null;
-    }
-    metaFor(obj).removeFromListeners(eventName, target, method);
-}
-/**
-  Send an event. The execution of suspended listeners
-  is skipped, and once listeners are removed. A listener without
-  a target is executed on the passed object. If an array of actions
-  is not passed, the actions stored on the passed object are invoked.
-
-  @method sendEvent
-  @static
-  @for @ember/object/events
-  @param obj
-  @param {String} eventName
-  @param {Array} params Optional parameters for each listener.
-  @return true
-  @public
-*/
-export function sendEvent(obj, eventName, params, actions, _meta) {
-    if (actions === undefined) {
-        let meta = _meta === undefined ? peekMeta(obj) : _meta;
-        actions = typeof meta === 'object' && meta !== null && meta.matchingListeners(eventName);
-    }
-    if (actions === undefined || actions.length === 0) {
-        return false;
-    }
-    for (let i = actions.length - 3; i >= 0; i -= 3) {
-        // looping in reverse for once listeners
-        let target = actions[i];
-        let method = actions[i + 1];
-        let once = actions[i + 2];
-        if (!method) {
-            continue;
-        }
-        if (once) {
-            removeListener(obj, eventName, target, method);
-        }
-        if (!target) {
-            target = obj;
-        }
-        if ('string' === typeof method) {
-            method = target[method];
-        }
-        method.apply(target, params);
-    }
-    return true;
-}
-/**
-  @private
-  @method hasListeners
-  @static
-  @for @ember/object/events
-  @param obj
-  @param {String} eventName
-*/
-export function hasListeners(obj, eventName) {
-    let meta = peekMeta(obj);
-    if (meta === undefined) {
-        return false;
-    }
-    let matched = meta.matchingListeners(eventName);
-    return matched !== undefined && matched.length > 0;
-}
-/**
-  Define a property as a function that should be executed when
-  a specified event or events are triggered.
-
-  ``` javascript
-  import EmberObject from '@ember/object';
-  import { on } from '@ember/object/evented';
-  import { sendEvent } from '@ember/object/events';
-
-  let Job = EmberObject.extend({
-    logCompleted: on('completed', function() {
-      console.log('Job completed!');
-    })
-  });
-
-  let job = Job.create();
-
-  sendEvent(job, 'completed'); // Logs 'Job completed!'
- ```
-
-  @method on
-  @static
-  @for @ember/object/evented
-  @param {String} eventNames*
-  @param {Function} func
-  @return func
-  @public
-*/
-export function on(...args) {
-    let func = args.pop();
-    let events = args;
-    assert('on expects function as last argument', typeof func === 'function');
-    assert('on called without valid event names', events.length > 0 && events.every(p => typeof p === 'string' && p.length > 0));
-    setListeners(func, events);
-    return func;
-}