discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,198 +0,0 @@
-import { deprecate } from '@ember/debug';
-import { PROPERTY_DID_CHANGE as ENABLE_PROPERTY_DID_CHANGE, PROPERTY_WILL_CHANGE as ENABLE_PROPERTY_WILL_CHANGE, } from '@ember/deprecated-features';
-import { DEBUG } from '@glimmer/env';
-import { descriptorFor, peekMeta } from 'ember-meta';
-import { symbol } from 'ember-utils';
-import changeEvent from './change_event';
-import { sendEvent } from './events';
-import ObserverSet from './observer_set';
-import { markObjectAsDirty } from './tags';
-import { assertNotRendered } from './transaction';
-/**
- @module ember
- @private
- */
-export const PROPERTY_DID_CHANGE = symbol('PROPERTY_DID_CHANGE');
-const observerSet = new ObserverSet();
-let deferred = 0;
-// ..........................................................
-// PROPERTY CHANGES
-//
-/**
-  @method propertyWillChange
-  @for Ember
-  @private
-*/
-let propertyWillChange;
-if (ENABLE_PROPERTY_WILL_CHANGE) {
-    propertyWillChange = function propertyWillChange() {
-        deprecate(`'propertyWillChange' is deprecated and has no effect. It is safe to remove this call.`, false, {
-            id: 'ember-metal.deprecate-propertyWillChange',
-            until: '3.5.0',
-            url: 'https://emberjs.com/deprecations/v3.x/#toc_use-notifypropertychange-instead-of-propertywillchange-and-propertydidchange',
-        });
-    };
-}
-/**
-  @method propertyDidChange
-  @for Ember
-  @private
-*/
-let propertyDidChange;
-if (ENABLE_PROPERTY_DID_CHANGE) {
-    propertyDidChange = function propertyDidChange(obj, keyName, _meta) {
-        deprecate(`'propertyDidChange' is deprecated in favor of 'notifyPropertyChange'. It is safe to change this call to 'notifyPropertyChange'.`, false, {
-            id: 'ember-metal.deprecate-propertyDidChange',
-            until: '3.5.0',
-            url: 'https://emberjs.com/deprecations/v3.x/#toc_use-notifypropertychange-instead-of-propertywillchange-and-propertydidchange',
-        });
-        notifyPropertyChange(obj, keyName, _meta);
-    };
-}
-/**
-  This function is called just after an object property has changed.
-  It will notify any observers and clear caches among other things.
-
-  Normally you will not need to call this method directly but if for some
-  reason you can't directly watch a property you can invoke this method
-  manually.
-
-  @method notifyPropertyChange
-  @for Ember
-  @param {Object} obj The object with the property that will change
-  @param {String} keyName The property key (or path) that will change.
-  @param {Meta} meta The objects meta.
-  @return {void}
-  @public
-*/
-function notifyPropertyChange(obj, keyName, _meta) {
-    let meta = _meta === undefined ? peekMeta(obj) : _meta;
-    let hasMeta = meta !== undefined;
-    if (hasMeta && !meta.isInitialized(obj)) {
-        return;
-    }
-    let possibleDesc = descriptorFor(obj, keyName, meta);
-    if (possibleDesc !== undefined && typeof possibleDesc.didChange === 'function') {
-        possibleDesc.didChange(obj, keyName);
-    }
-    if (hasMeta && meta.peekWatching(keyName) > 0) {
-        dependentKeysDidChange(obj, keyName, meta);
-        chainsDidChange(obj, keyName, meta);
-        notifyObservers(obj, keyName, meta);
-    }
-    if (PROPERTY_DID_CHANGE in obj) {
-        obj[PROPERTY_DID_CHANGE](keyName);
-    }
-    if (hasMeta) {
-        if (meta.isSourceDestroying()) {
-            return;
-        }
-        markObjectAsDirty(obj, keyName, meta);
-    }
-    if (DEBUG) {
-        assertNotRendered(obj, keyName);
-    }
-}
-const SEEN_MAP = new Map();
-let IS_TOP_SEEN_MAP = true;
-// called whenever a property has just changed to update dependent keys
-function dependentKeysDidChange(obj, depKey, meta) {
-    if (meta.isSourceDestroying() || !meta.hasDeps(depKey)) {
-        return;
-    }
-    let seen = SEEN_MAP;
-    let isTop = IS_TOP_SEEN_MAP;
-    if (isTop) {
-        IS_TOP_SEEN_MAP = false;
-    }
-    iterDeps(notifyPropertyChange, obj, depKey, seen, meta);
-    if (isTop) {
-        SEEN_MAP.clear();
-        IS_TOP_SEEN_MAP = true;
-    }
-}
-function iterDeps(method, obj, depKey, seen, meta) {
-    let current = seen.get(obj);
-    if (current === undefined) {
-        current = new Set();
-        seen.set(obj, current);
-    }
-    if (current.has(depKey)) {
-        return;
-    }
-    let possibleDesc;
-    meta.forEachInDeps(depKey, (key) => {
-        possibleDesc = descriptorFor(obj, key, meta);
-        if (possibleDesc !== undefined && possibleDesc._suspended === obj) {
-            return;
-        }
-        method(obj, key, meta);
-    });
-}
-function chainsDidChange(_obj, keyName, meta) {
-    let chainWatchers = meta.readableChainWatchers();
-    if (chainWatchers !== undefined) {
-        chainWatchers.notify(keyName, true, notifyPropertyChange);
-    }
-}
-function overrideChains(_obj, keyName, meta) {
-    let chainWatchers = meta.readableChainWatchers();
-    if (chainWatchers !== undefined) {
-        chainWatchers.revalidate(keyName);
-    }
-}
-/**
-  @method beginPropertyChanges
-  @chainable
-  @private
-*/
-function beginPropertyChanges() {
-    deferred++;
-}
-/**
-  @method endPropertyChanges
-  @private
-*/
-function endPropertyChanges() {
-    deferred--;
-    if (deferred <= 0) {
-        observerSet.flush();
-    }
-}
-/**
-  Make a series of property changes together in an
-  exception-safe way.
-
-  ```javascript
-  Ember.changeProperties(function() {
-    obj1.set('foo', mayBlowUpWhenSet);
-    obj2.set('bar', baz);
-  });
-  ```
-
-  @method changeProperties
-  @param {Function} callback
-  @private
-*/
-function changeProperties(callback) {
-    beginPropertyChanges();
-    try {
-        callback();
-    }
-    finally {
-        endPropertyChanges();
-    }
-}
-function notifyObservers(obj, keyName, meta) {
-    if (meta.isSourceDestroying()) {
-        return;
-    }
-    let eventName = changeEvent(keyName);
-    if (deferred > 0) {
-        observerSet.add(obj, keyName, eventName);
-    }
-    else {
-        sendEvent(obj, eventName, [obj, keyName]);
-    }
-}
-export { propertyWillChange, propertyDidChange, notifyPropertyChange, overrideChains, beginPropertyChanges, endPropertyChanges, changeProperties, };

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

@@ -1,160 +0,0 @@
-/**
-@module @ember/object
-*/
-import { EMBER_METAL_TRACKED_PROPERTIES } from '@ember/canary-features';
-import { assert, deprecate } from '@ember/debug';
-import { PROPERTY_BASED_DESCRIPTORS } from '@ember/deprecated-features';
-import { DEBUG } from '@glimmer/env';
-import { descriptorFor, isDescriptor, meta } from 'ember-meta';
-import { HAS_NATIVE_PROXY, symbol, toString } from 'ember-utils';
-import { isPath } from './path_cache';
-import { tagForProperty } from './tags';
-import { getCurrentTracker } from './tracked';
-export const PROXY_CONTENT = symbol('PROXY_CONTENT');
-export let getPossibleMandatoryProxyValue;
-if (DEBUG && HAS_NATIVE_PROXY) {
-    getPossibleMandatoryProxyValue = function getPossibleMandatoryProxyValue(obj, keyName) {
-        let content = obj[PROXY_CONTENT];
-        if (content === undefined) {
-            return obj[keyName];
-        }
-        else {
-            /* global Reflect */
-            return Reflect.get(content, keyName, obj);
-        }
-    };
-}
-// ..........................................................
-// GET AND SET
-//
-// If we are on a platform that supports accessors we can use those.
-// Otherwise simulate accessors by looking up the property directly on the
-// object.
-/**
-  Gets the value of a property on an object. If the property is computed,
-  the function will be invoked. If the property is not defined but the
-  object implements the `unknownProperty` method then that will be invoked.
-
-  ```javascript
-  import { get } from '@ember/object';
-  get(obj, "name");
-  ```
-
-  If you plan to run on IE8 and older browsers then you should use this
-  method anytime you want to retrieve a property on an object that you don't
-  know for sure is private. (Properties beginning with an underscore '_'
-  are considered private.)
-
-  On all newer browsers, you only need to use this method to retrieve
-  properties if the property might not be defined on the object and you want
-  to respect the `unknownProperty` handler. Otherwise you can ignore this
-  method.
-
-  Note that if the object itself is `undefined`, this method will throw
-  an error.
-
-  @method get
-  @for @ember/object
-  @static
-  @param {Object} obj The object to retrieve from.
-  @param {String} keyName The property key to retrieve
-  @return {Object} the property value or `null`.
-  @public
-*/
-export function get(obj, keyName) {
-    assert(`Get must be called with two arguments; an object and a property key`, arguments.length === 2);
-    assert(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null);
-    assert(`The key provided to get must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || (typeof keyName === 'number' && !isNaN(keyName)));
-    assert(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0);
-    let type = typeof obj;
-    let isObject = type === 'object';
-    let isFunction = type === 'function';
-    let isObjectLike = isObject || isFunction;
-    let descriptor;
-    let value;
-    if (isObjectLike) {
-        if (EMBER_METAL_TRACKED_PROPERTIES) {
-            let tracker = getCurrentTracker();
-            if (tracker)
-                tracker.add(tagForProperty(obj, keyName));
-        }
-        descriptor = descriptorFor(obj, keyName);
-        if (descriptor !== undefined) {
-            return descriptor.get(obj, keyName);
-        }
-        if (DEBUG && HAS_NATIVE_PROXY) {
-            value = getPossibleMandatoryProxyValue(obj, keyName);
-        }
-        else {
-            value = obj[keyName];
-        }
-        if (PROPERTY_BASED_DESCRIPTORS && isDescriptor(value)) {
-            deprecate(`[DEPRECATED] computed property '${keyName}' was not set on object '${toString(obj)}' via 'defineProperty'`, false, {
-                id: 'ember-meta.descriptor-on-object',
-                until: '3.5.0',
-                url: 'https://emberjs.com/deprecations/v3.x#toc_use-defineProperty-to-define-computed-properties',
-            });
-            Object.defineProperty(obj, keyName, {
-                configurable: true,
-                enumerable: value.enumerable === false,
-                get() {
-                    return value.get(this, keyName);
-                },
-            });
-            meta(obj).writeDescriptors(keyName, value);
-            value.setup(obj, keyName);
-            return value.get(obj, keyName);
-        }
-    }
-    else {
-        value = obj[keyName];
-    }
-    if (value === undefined) {
-        if (isPath(keyName)) {
-            return _getPath(obj, keyName);
-        }
-        if (isObject &&
-            !(keyName in obj) &&
-            typeof obj.unknownProperty === 'function') {
-            return obj.unknownProperty(keyName);
-        }
-    }
-    return value;
-}
-export function _getPath(root, path) {
-    let obj = root;
-    let parts = path.split('.');
-    for (let i = 0; i < parts.length; i++) {
-        if (obj === undefined || obj === null || obj.isDestroyed) {
-            return undefined;
-        }
-        obj = get(obj, parts[i]);
-    }
-    return obj;
-}
-/**
-  Retrieves the value of a property from an Object, or a default value in the
-  case that the property returns `undefined`.
-
-  ```javascript
-  import { getWithDefault } from '@ember/object';
-  getWithDefault(person, 'lastName', 'Doe');
-  ```
-
-  @method getWithDefault
-  @for @ember/object
-  @static
-  @param {Object} obj The object to retrieve from.
-  @param {String} keyName The name of the property to retrieve
-  @param {Object} defaultValue The value to return if the property value is undefined
-  @return {Object} The property value or the defaultValue.
-  @public
-*/
-export function getWithDefault(root, key, defaultValue) {
-    let value = get(root, key);
-    if (value === undefined) {
-        return defaultValue;
-    }
-    return value;
-}
-export default get;

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

@@ -1,157 +0,0 @@
-import { assert, deprecate } from '@ember/debug';
-import { PROPERTY_BASED_DESCRIPTORS } from '@ember/deprecated-features';
-import EmberError from '@ember/error';
-import { DEBUG } from '@glimmer/env';
-import { descriptorFor, isDescriptor, meta, peekMeta } from 'ember-meta';
-import { HAS_NATIVE_PROXY, toString } from 'ember-utils';
-import { isPath } from './path_cache';
-import { notifyPropertyChange } from './property_events';
-import { _getPath as getPath, getPossibleMandatoryProxyValue } from './property_get';
-let setWithMandatorySetter;
-let makeEnumerable;
-/**
- @module @ember/object
-*/
-/**
-  Sets the value of a property on an object, respecting computed properties
-  and notifying observers and other listeners of the change.
-  If the specified property is not defined on the object and the object
-  implements the `setUnknownProperty` method, then instead of setting the
-  value of the property on the object, its `setUnknownProperty` handler
-  will be invoked with the two parameters `keyName` and `value`.
-
-  ```javascript
-  import { set } from '@ember/object';
-  set(obj, "name", value);
-  ```
-
-  @method set
-  @static
-  @for @ember/object
-  @param {Object} obj The object to modify.
-  @param {String} keyName The property key to set
-  @param {Object} value The value to set
-  @return {Object} the passed value.
-  @public
-*/
-export function set(obj, keyName, value, tolerant) {
-    assert(`Set must be called with three or four arguments; an object, a property key, a value and tolerant true/false`, arguments.length === 3 || arguments.length === 4);
-    assert(`Cannot call set with '${keyName}' on an undefined object.`, (obj && typeof obj === 'object') || typeof obj === 'function');
-    assert(`The key provided to set must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || (typeof keyName === 'number' && !isNaN(keyName)));
-    assert(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0);
-    if (obj.isDestroyed) {
-        assert(`calling set on destroyed object: ${toString(obj)}.${keyName} = ${toString(value)}`, tolerant);
-        return;
-    }
-    if (isPath(keyName)) {
-        return setPath(obj, keyName, value, tolerant);
-    }
-    let possibleDesc = descriptorFor(obj, keyName);
-    if (possibleDesc !== undefined) {
-        /* computed property */
-        possibleDesc.set(obj, keyName, value);
-        return value;
-    }
-    let currentValue;
-    if (DEBUG && HAS_NATIVE_PROXY) {
-        currentValue = getPossibleMandatoryProxyValue(obj, keyName);
-    }
-    else {
-        currentValue = obj[keyName];
-    }
-    if (PROPERTY_BASED_DESCRIPTORS && isDescriptor(currentValue)) {
-        deprecate(`[DEPRECATED] computed property '${keyName}' was not set on object '${toString(obj)}' via 'defineProperty'`, false, {
-            id: 'ember-meta.descriptor-on-object',
-            until: '3.5.0',
-            url: 'https://emberjs.com/deprecations/v3.x#toc_use-defineProperty-to-define-computed-properties',
-        });
-        let cv = currentValue;
-        Object.defineProperty(obj, keyName, {
-            configurable: true,
-            enumerable: cv.enumerable === false,
-            get() {
-                return cv.get(this, keyName);
-            },
-        });
-        meta(obj).writeDescriptors(keyName, cv);
-        cv.setup(obj, keyName);
-        cv.set(obj, keyName, value);
-        return value;
-    }
-    if (currentValue === undefined &&
-        'object' === typeof obj &&
-        !(keyName in obj) &&
-        typeof obj.setUnknownProperty === 'function') {
-        /* unknown property */
-        obj.setUnknownProperty(keyName, value);
-    }
-    else {
-        let meta = peekMeta(obj);
-        if (DEBUG) {
-            setWithMandatorySetter(meta, obj, keyName, value);
-        }
-        else {
-            obj[keyName] = value;
-        }
-        if (currentValue !== value) {
-            notifyPropertyChange(obj, keyName, meta);
-        }
-    }
-    return value;
-}
-if (DEBUG) {
-    setWithMandatorySetter = (meta, obj, keyName, value) => {
-        if (meta !== undefined && meta.peekWatching(keyName) > 0) {
-            makeEnumerable(obj, keyName);
-            meta.writeValue(obj, keyName, value);
-        }
-        else {
-            obj[keyName] = value;
-        }
-    };
-    makeEnumerable = (obj, key) => {
-        let desc = Object.getOwnPropertyDescriptor(obj, key);
-        if (desc && desc.set && desc.set.isMandatorySetter) {
-            desc.enumerable = true;
-            Object.defineProperty(obj, key, desc);
-        }
-    };
-}
-function setPath(root, path, value, tolerant) {
-    let parts = path.split('.');
-    let keyName = parts.pop();
-    assert('Property set failed: You passed an empty path', keyName.trim().length > 0);
-    let newPath = parts.join('.');
-    let newRoot = getPath(root, newPath);
-    if (newRoot !== null && newRoot !== undefined) {
-        return set(newRoot, keyName, value);
-    }
-    else if (!tolerant) {
-        throw new EmberError(`Property set failed: object in path "${newPath}" could not be found.`);
-    }
-}
-/**
-  Error-tolerant form of `set`. Will not blow up if any part of the
-  chain is `undefined`, `null`, or destroyed.
-
-  This is primarily used when syncing bindings, which may try to update after
-  an object has been destroyed.
-
-  ```javascript
-  import { trySet } from '@ember/object';
-
-  let obj = { name: "Zoey" };
-  trySet(obj, "contacts.twitter", "@emberjs");
-  ```
-
-  @method trySet
-  @static
-  @for @ember/object
-  @param {Object} root The object to modify.
-  @param {String} path The property path to set
-  @param {Object} value The value to set
-  @public
-*/
-export function trySet(root, path, value) {
-    return set(root, path, value, true);
-}