discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,113 +0,0 @@
-import { DEBUG } from '@glimmer/env';
-import { descriptorFor, isDescriptor, meta as metaFor, peekMeta, UNDEFINED, } from 'ember-meta';
-import { lookupDescriptor } from 'ember-utils';
-import { DEFAULT_GETTER_FUNCTION, INHERITING_GETTER_FUNCTION, MANDATORY_SETTER_FUNCTION, } from './properties';
-let handleMandatorySetter;
-export function watchKey(obj, keyName, _meta) {
-    let meta = _meta === undefined ? metaFor(obj) : _meta;
-    let count = meta.peekWatching(keyName);
-    meta.writeWatching(keyName, count + 1);
-    if (count === 0) {
-        // activate watching first time
-        let possibleDesc = descriptorFor(obj, keyName, meta);
-        if (possibleDesc !== undefined && possibleDesc.willWatch !== undefined) {
-            possibleDesc.willWatch(obj, keyName, meta);
-        }
-        if (typeof obj.willWatchProperty === 'function') {
-            obj.willWatchProperty(keyName);
-        }
-        if (DEBUG) {
-            // NOTE: this is dropped for prod + minified builds
-            handleMandatorySetter(meta, obj, keyName);
-        }
-    }
-}
-if (DEBUG) {
-    let hasOwnProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-    let propertyIsEnumerable = (obj, key) => Object.prototype.propertyIsEnumerable.call(obj, key);
-    // Future traveler, although this code looks scary. It merely exists in
-    // development to aid in development asertions. Production builds of
-    // ember strip this entire block out
-    handleMandatorySetter = function handleMandatorySetter(m, obj, keyName) {
-        let descriptor = lookupDescriptor(obj, keyName);
-        let hasDescriptor = descriptor !== null;
-        let possibleDesc = hasDescriptor && descriptor.value;
-        if (isDescriptor(possibleDesc)) {
-            return;
-        }
-        let configurable = hasDescriptor ? descriptor.configurable : true;
-        let isWritable = hasDescriptor ? descriptor.writable : true;
-        let hasValue = hasDescriptor ? 'value' in descriptor : true;
-        // this x in Y deopts, so keeping it in this function is better;
-        if (configurable && isWritable && hasValue && keyName in obj) {
-            let desc = {
-                configurable: true,
-                set: MANDATORY_SETTER_FUNCTION(keyName),
-                enumerable: propertyIsEnumerable(obj, keyName),
-                get: undefined,
-            };
-            if (hasOwnProperty(obj, keyName)) {
-                m.writeValues(keyName, obj[keyName]);
-                desc.get = DEFAULT_GETTER_FUNCTION(keyName);
-            }
-            else {
-                desc.get = INHERITING_GETTER_FUNCTION(keyName);
-            }
-            Object.defineProperty(obj, keyName, desc);
-        }
-    };
-}
-export function unwatchKey(obj, keyName, _meta) {
-    let meta = _meta === undefined ? peekMeta(obj) : _meta;
-    // do nothing of this object has already been destroyed
-    if (meta === undefined || meta.isSourceDestroyed()) {
-        return;
-    }
-    let count = meta.peekWatching(keyName);
-    if (count === 1) {
-        meta.writeWatching(keyName, 0);
-        let possibleDesc = descriptorFor(obj, keyName, meta);
-        let isDescriptor = possibleDesc !== undefined;
-        if (isDescriptor && possibleDesc.didUnwatch !== undefined) {
-            possibleDesc.didUnwatch(obj, keyName, meta);
-        }
-        if (typeof obj.didUnwatchProperty === 'function') {
-            obj.didUnwatchProperty(keyName);
-        }
-        if (DEBUG) {
-            // It is true, the following code looks quite WAT. But have no fear, It
-            // exists purely to improve development ergonomics and is removed from
-            // ember.min.js and ember.prod.js builds.
-            //
-            // Some further context: Once a property is watched by ember, bypassing `set`
-            // for mutation, will bypass observation. This code exists to assert when
-            // that occurs, and attempt to provide more helpful feedback. The alternative
-            // is tricky to debug partially observable properties.
-            if (!isDescriptor && keyName in obj) {
-                let maybeMandatoryDescriptor = lookupDescriptor(obj, keyName);
-                if (maybeMandatoryDescriptor &&
-                    maybeMandatoryDescriptor.set &&
-                    maybeMandatoryDescriptor.set.isMandatorySetter) {
-                    if (maybeMandatoryDescriptor.get &&
-                        maybeMandatoryDescriptor.get.isInheritingGetter) {
-                        let possibleValue = meta.readInheritedValue('values', keyName);
-                        if (possibleValue === UNDEFINED) {
-                            delete obj[keyName];
-                            return;
-                        }
-                    }
-                    Object.defineProperty(obj, keyName, {
-                        configurable: true,
-                        enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
-                        writable: true,
-                        value: meta.peekValues(keyName),
-                    });
-                    meta.deleteFromValues(keyName);
-                }
-            }
-        }
-    }
-    else if (count > 1) {
-        meta.writeWatching(keyName, count - 1);
-    }
-}

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

@@ -1,24 +0,0 @@
-import { meta as metaFor, peekMeta } from 'ember-meta';
-import { makeChainNode } from './chains';
-export function watchPath(obj, keyPath, meta) {
-    let m = meta === undefined ? metaFor(obj) : meta;
-    let counter = m.peekWatching(keyPath);
-    m.writeWatching(keyPath, counter + 1);
-    if (counter === 0) {
-        // activate watching first time
-        m.writableChains(makeChainNode).add(keyPath);
-    }
-}
-export function unwatchPath(obj, keyPath, meta) {
-    let m = meta === undefined ? peekMeta(obj) : meta;
-    if (m === undefined) {
-        return;
-    }
-    let counter = m.peekWatching(keyPath);
-    if (counter > 0) {
-        m.writeWatching(keyPath, counter - 1);
-        if (counter === 1) {
-            m.writableChains(makeChainNode).remove(keyPath);
-        }
-    }
-}

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

@@ -1,54 +0,0 @@
-/**
-@module ember
-*/
-import { peekMeta } from 'ember-meta';
-import { isPath } from './path_cache';
-import { unwatchKey, watchKey } from './watch_key';
-import { unwatchPath, watchPath } from './watch_path';
-/**
-  Starts watching a property on an object. Whenever the property changes,
-  invokes `Ember.notifyPropertyChange`. This is the primitive used by observers
-  and dependent keys; usually you will never call this method directly but instead
-  use higher level methods like `addObserver()`.
-
-  @private
-  @method watch
-  @for Ember
-  @param obj
-  @param {String} keyPath
-  @param {Object} meta
-*/
-export function watch(obj, keyPath, meta) {
-    if (isPath(keyPath)) {
-        watchPath(obj, keyPath, meta);
-    }
-    else {
-        watchKey(obj, keyPath, meta);
-    }
-}
-export function isWatching(obj, key) {
-    return watcherCount(obj, key) > 0;
-}
-export function watcherCount(obj, key) {
-    let meta = peekMeta(obj);
-    return (meta !== undefined && meta.peekWatching(key)) || 0;
-}
-/**
-  Stops watching a property on an object. Usually you will never call this method directly but instead
-  use higher level methods like `removeObserver()`.
-
-  @private
-  @method unwatch
-  @for Ember
-  @param obj
-  @param {String} keyPath
-  @param {Object} meta
-*/
-export function unwatch(obj, keyPath, meta) {
-    if (isPath(keyPath)) {
-        unwatchPath(obj, keyPath, meta);
-    }
-    else {
-        unwatchKey(obj, keyPath, meta);
-    }
-}

data/dist/es/ember-metal/tests/accessors/get_path_test.js

@@ -1,82 +0,0 @@
-import { get } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let obj;
-
-moduleFor(
-  'get with path',
-  class extends AbstractTestCase {
-    constructor() {
-      super();
-      obj = {
-        foo: {
-          bar: {
-            baz: { biff: 'BIFF' },
-          },
-        },
-        foothis: {
-          bar: {
-            baz: { biff: 'BIFF' },
-          },
-        },
-        falseValue: false,
-        emptyString: '',
-        Wuz: {
-          nar: 'foo',
-        },
-        nullValue: null,
-      };
-    }
-
-    teardown() {
-      obj = undefined;
-    }
-
-    // ..........................................................
-    // LOCAL PATHS
-    //
-    ['@test [obj, foo] -> obj.foo'](assert) {
-      assert.deepEqual(get(obj, 'foo'), obj.foo);
-    }
-
-    ['@test [obj, foo.bar] -> obj.foo.bar'](assert) {
-      assert.deepEqual(get(obj, 'foo.bar'), obj.foo.bar);
-    }
-
-    ['@test [obj, foothis.bar] -> obj.foothis.bar'](assert) {
-      assert.deepEqual(get(obj, 'foothis.bar'), obj.foothis.bar);
-    }
-
-    ['@test [obj, falseValue.notDefined] -> (undefined)'](assert) {
-      assert.strictEqual(get(obj, 'falseValue.notDefined'), undefined);
-    }
-
-    ['@test [obj, emptyString.length] -> 0'](assert) {
-      assert.strictEqual(get(obj, 'emptyString.length'), 0);
-    }
-
-    ['@test [obj, nullValue.notDefined] -> (undefined)'](assert) {
-      assert.strictEqual(get(obj, 'nullValue.notDefined'), undefined);
-    }
-
-    // ..........................................................
-    // GLOBAL PATHS TREATED LOCAL WITH GET
-    //
-
-    ['@test [obj, Wuz] -> obj.Wuz'](assert) {
-      assert.deepEqual(get(obj, 'Wuz'), obj.Wuz);
-    }
-
-    ['@test [obj, Wuz.nar] -> obj.Wuz.nar'](assert) {
-      assert.deepEqual(get(obj, 'Wuz.nar'), obj.Wuz.nar);
-    }
-
-    ['@test [obj, Foo] -> (undefined)'](assert) {
-      assert.strictEqual(get(obj, 'Foo'), undefined);
-    }
-
-    ['@test [obj, Foo.bar] -> (undefined)'](assert) {
-      assert.strictEqual(get(obj, 'Foo.bar'), undefined);
-    }
-  }
-);

data/dist/es/ember-metal/tests/accessors/get_properties_test.js

@@ -1,36 +0,0 @@
-import { getProperties } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'getProperties',
-  class extends AbstractTestCase {
-    ['@test can retrieve a hash of properties from an object via an argument list or array of property names'](
-      assert
-    ) {
-      let obj = {
-        firstName: 'Steve',
-        lastName: 'Jobs',
-        companyName: 'Apple, Inc.',
-      };
-
-      assert.deepEqual(getProperties(obj, 'firstName', 'lastName'), {
-        firstName: 'Steve',
-        lastName: 'Jobs',
-      });
-      assert.deepEqual(getProperties(obj, 'firstName', 'lastName'), {
-        firstName: 'Steve',
-        lastName: 'Jobs',
-      });
-      assert.deepEqual(getProperties(obj, 'lastName'), { lastName: 'Jobs' });
-      assert.deepEqual(getProperties(obj), {});
-      assert.deepEqual(getProperties(obj, ['firstName', 'lastName']), {
-        firstName: 'Steve',
-        lastName: 'Jobs',
-      });
-      assert.deepEqual(getProperties(obj, ['firstName']), {
-        firstName: 'Steve',
-      });
-      assert.deepEqual(getProperties(obj, []), {});
-    }
-  }
-);

data/dist/es/ember-metal/tests/accessors/get_test.js

@@ -1,335 +0,0 @@
-import { ENV } from 'ember-environment';
-import { Object as EmberObject } from 'ember-runtime';
-import { get, getWithDefault, Mixin, observer, computed } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-import { run } from '@ember/runloop';
-
-function aget(x, y) {
-  return x[y];
-}
-
-moduleFor(
-  'get',
-  class extends AbstractTestCase {
-    ['@test should get arbitrary properties on an object'](assert) {
-      let obj = {
-        string: 'string',
-        number: 23,
-        boolTrue: true,
-        boolFalse: false,
-        nullValue: null,
-      };
-
-      for (let key in obj) {
-        if (!obj.hasOwnProperty(key)) {
-          continue;
-        }
-        assert.equal(get(obj, key), obj[key], key);
-      }
-    }
-
-    ['@test implicitly computing the values of descriptors on properties is deprecated'](assert) {
-      let cp = computed(() => 'value');
-      let obj = {
-        cp,
-        toString() {
-          return 'myobject';
-        },
-      };
-
-      let result;
-
-      expectDeprecation(() => {
-        result = get(obj, 'cp');
-      }, /\[DEPRECATED\] computed property 'cp' was not set on object 'myobject' via 'defineProperty'/);
-
-      assert.equal(result, 'value', 'descriptor');
-    }
-
-    ['@test should retrieve a number key on an object'](assert) {
-      let obj = { 1: 'first' };
-
-      assert.equal(get(obj, 1), 'first');
-    }
-
-    ['@test should retrieve an array index'](assert) {
-      let arr = ['first', 'second'];
-
-      assert.equal(get(arr, 0), 'first');
-      assert.equal(get(arr, 1), 'second');
-    }
-
-    ['@test should retrieve an empty string key on an object'](assert) {
-      let obj = { '': 'empty-string' };
-
-      assert.equal(get(obj, ''), 'empty-string');
-    }
-
-    ['@test should return undefined when passed an empty string if that key does not exist on an object'](
-      assert
-    ) {
-      let obj = { tomster: true };
-
-      assert.equal(get(obj, ''), undefined);
-    }
-
-    ['@test should not access a property more than once'](assert) {
-      let count = 0;
-      let obj = {
-        get id() {
-          return ++count;
-        },
-      };
-
-      get(obj, 'id');
-
-      assert.equal(count, 1);
-    }
-
-    ['@test should call unknownProperty on watched values if the value is undefined using getFromEmberMetal()/set()'](
-      assert
-    ) {
-      let obj = {
-        unknownProperty(key) {
-          assert.equal(key, 'foo', 'should pass key');
-          return 'FOO';
-        },
-      };
-      assert.equal(get(obj, 'foo'), 'FOO', 'should return value from unknown');
-    }
-
-    ['@test should call unknownProperty on watched values if the value is undefined using accessors'](
-      assert
-    ) {
-      if (ENV.USES_ACCESSORS) {
-        let obj = {
-          unknownProperty(key) {
-            assert.equal(key, 'foo', 'should pass key');
-            return 'FOO';
-          },
-        };
-        assert.equal(aget(obj, 'foo'), 'FOO', 'should return value from unknown');
-      } else {
-        assert.ok('SKIPPING ACCESSORS');
-      }
-    }
-
-    ['@test get works with paths correctly'](assert) {
-      let func = function() {};
-      func.bar = 'awesome';
-
-      let destroyedObj = EmberObject.create({ bar: 'great' });
-      run(() => destroyedObj.destroy());
-
-      assert.equal(get({ foo: null }, 'foo.bar'), undefined);
-      assert.equal(get({ foo: { bar: 'hello' } }, 'foo.bar.length'), 5);
-      assert.equal(get({ foo: func }, 'foo.bar'), 'awesome');
-      assert.equal(get({ foo: func }, 'foo.bar.length'), 7);
-      assert.equal(get({}, 'foo.bar.length'), undefined);
-      assert.equal(get(function() {}, 'foo.bar.length'), undefined);
-      assert.equal(get('', 'foo.bar.length'), undefined);
-      assert.equal(get({ foo: destroyedObj }, 'foo.bar'), undefined);
-    }
-
-    ['@test warn on attempts to call get with no arguments']() {
-      expectAssertion(function() {
-        get('aProperty');
-      }, /Get must be called with two arguments;/i);
-    }
-
-    ['@test warn on attempts to call get with only one argument']() {
-      expectAssertion(function() {
-        get('aProperty');
-      }, /Get must be called with two arguments;/i);
-    }
-
-    ['@test warn on attempts to call get with more then two arguments']() {
-      expectAssertion(function() {
-        get({}, 'aProperty', true);
-      }, /Get must be called with two arguments;/i);
-    }
-
-    ['@test warn on attempts to get a property of undefined']() {
-      expectAssertion(function() {
-        get(undefined, 'aProperty');
-      }, /Cannot call get with 'aProperty' on an undefined object/i);
-    }
-
-    ['@test warn on attempts to get a property path of undefined']() {
-      expectAssertion(function() {
-        get(undefined, 'aProperty.on.aPath');
-      }, /Cannot call get with 'aProperty.on.aPath' on an undefined object/);
-    }
-
-    ['@test warn on attempts to get a property of null']() {
-      expectAssertion(function() {
-        get(null, 'aProperty');
-      }, /Cannot call get with 'aProperty' on an undefined object/);
-    }
-
-    ['@test warn on attempts to get a property path of null']() {
-      expectAssertion(function() {
-        get(null, 'aProperty.on.aPath');
-      }, /Cannot call get with 'aProperty.on.aPath' on an undefined object/);
-    }
-
-    ['@test warn on attempts to use get with an unsupported property path']() {
-      let obj = {};
-      expectAssertion(
-        () => get(obj, null),
-        /The key provided to get must be a string or number, you passed null/
-      );
-      expectAssertion(
-        () => get(obj, NaN),
-        /The key provided to get must be a string or number, you passed NaN/
-      );
-      expectAssertion(
-        () => get(obj, undefined),
-        /The key provided to get must be a string or number, you passed undefined/
-      );
-      expectAssertion(
-        () => get(obj, false),
-        /The key provided to get must be a string or number, you passed false/
-      );
-    }
-
-    // ..........................................................
-    // BUGS
-    //
-
-    ['@test (regression) watched properties on unmodified inherited objects should still return their original value'](
-      assert
-    ) {
-      let MyMixin = Mixin.create({
-        someProperty: 'foo',
-        propertyDidChange: observer('someProperty', () => {}),
-      });
-
-      let baseObject = MyMixin.apply({});
-      let theRealObject = Object.create(baseObject);
-
-      assert.equal(
-        get(theRealObject, 'someProperty'),
-        'foo',
-        'should return the set value, not false'
-      );
-    }
-  }
-);
-
-moduleFor(
-  'getWithDefault',
-  class extends AbstractTestCase {
-    ['@test should get arbitrary properties on an object'](assert) {
-      let obj = {
-        string: 'string',
-        number: 23,
-        boolTrue: true,
-        boolFalse: false,
-        nullValue: null,
-      };
-
-      for (let key in obj) {
-        if (!obj.hasOwnProperty(key)) {
-          continue;
-        }
-        assert.equal(getWithDefault(obj, key, 'fail'), obj[key], key);
-      }
-
-      obj = {
-        undef: undefined,
-      };
-
-      assert.equal(
-        getWithDefault(obj, 'undef', 'default'),
-        'default',
-        'explicit undefined retrieves the default'
-      );
-      assert.equal(
-        getWithDefault(obj, 'not-present', 'default'),
-        'default',
-        'non-present key retrieves the default'
-      );
-    }
-
-    ['@test should call unknownProperty if defined and value is undefined'](assert) {
-      let obj = {
-        count: 0,
-        unknownProperty(key) {
-          assert.equal(key, 'foo', 'should pass key');
-          this.count++;
-          return 'FOO';
-        },
-      };
-
-      assert.equal(get(obj, 'foo'), 'FOO', 'should return value from unknown');
-      assert.equal(obj.count, 1, 'should have invoked');
-    }
-
-    ['@test if unknownProperty is present, it is called using getFromEmberMetal()/set()'](assert) {
-      let obj = {
-        unknownProperty(key) {
-          if (key === 'foo') {
-            assert.equal(key, 'foo', 'should pass key');
-            return 'FOO';
-          }
-        },
-      };
-      assert.equal(
-        getWithDefault(obj, 'foo', 'fail'),
-        'FOO',
-        'should return value from unknownProperty'
-      );
-      assert.equal(
-        getWithDefault(obj, 'bar', 'default'),
-        'default',
-        'should convert undefined from unknownProperty into default'
-      );
-    }
-
-    ['@test if unknownProperty is present, it is called using accessors'](assert) {
-      if (ENV.USES_ACCESSORS) {
-        let obj = {
-          unknownProperty(key) {
-            if (key === 'foo') {
-              assert.equal(key, 'foo', 'should pass key');
-              return 'FOO';
-            }
-          },
-        };
-        assert.equal(aget(obj, 'foo', 'fail'), 'FOO', 'should return value from unknownProperty');
-        assert.equal(
-          aget(obj, 'bar', 'default'),
-          'default',
-          'should convert undefined from unknownProperty into default'
-        );
-      } else {
-        assert.ok('SKIPPING ACCESSORS');
-      }
-    }
-
-    // ..........................................................
-    // BUGS
-    //
-
-    ['@test (regression) watched properties on unmodified inherited objects should still return their original value'](
-      assert
-    ) {
-      let MyMixin = Mixin.create({
-        someProperty: 'foo',
-        propertyDidChange: observer('someProperty', () => {
-          /* nothing to do */
-        }),
-      });
-
-      let baseObject = MyMixin.apply({});
-      let theRealObject = Object.create(baseObject);
-
-      assert.equal(
-        getWithDefault(theRealObject, 'someProperty', 'fail'),
-        'foo',
-        'should return the set value, not false'
-      );
-    }
-  }
-);