discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@ember/runloop/tests/onerror_test.js

@@ -1,59 +0,0 @@
-import { run } from '..';
-import {
-  getDispatchOverride,
-  getOnerror,
-  setDispatchOverride,
-  setOnerror,
-} from 'ember-error-handling';
-import { isTesting, setTesting } from '@ember/debug';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'system/run_loop/onerror_test',
-  class extends AbstractTestCase {
-    ['@test With Ember.onerror undefined, errors in run are thrown'](assert) {
-      let thrown = new Error('Boom!');
-      let original = getOnerror();
-
-      let caught;
-      setOnerror(undefined);
-      try {
-        run(() => {
-          throw thrown;
-        });
-      } catch (error) {
-        caught = error;
-      } finally {
-        setOnerror(original);
-      }
-
-      assert.deepEqual(caught, thrown);
-    }
-
-    ['@test With Ember.onerror set, errors in run are caught'](assert) {
-      let thrown = new Error('Boom!');
-      let original = getOnerror();
-      let originalDispatchOverride = getDispatchOverride();
-      let originalIsTesting = isTesting();
-
-      let caught;
-      setOnerror(error => {
-        caught = error;
-      });
-      setDispatchOverride(null);
-      setTesting(false);
-
-      try {
-        run(() => {
-          throw thrown;
-        });
-      } finally {
-        setOnerror(original);
-        setDispatchOverride(originalDispatchOverride);
-        setTesting(originalIsTesting);
-      }
-
-      assert.deepEqual(caught, thrown);
-    }
-  }
-);

data/dist/es/@ember/runloop/tests/run_bind_test.js

@@ -1,59 +0,0 @@
-import { bind, getCurrentRunLoop } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'system/run_loop/run_bind_test',
-  class extends AbstractTestCase {
-    ['@test bind builds a run-loop wrapped callback handler'](assert) {
-      assert.expect(3);
-
-      let obj = {
-        value: 0,
-        increment(increment) {
-          assert.ok(getCurrentRunLoop(), 'expected a run-loop');
-          return (this.value += increment);
-        },
-      };
-
-      let proxiedFunction = bind(obj, obj.increment, 1);
-      assert.equal(proxiedFunction(), 1);
-      assert.equal(obj.value, 1);
-    }
-
-    ['@test bind keeps the async callback arguments'](assert) {
-      assert.expect(4);
-
-      function asyncCallback(increment, increment2, increment3) {
-        assert.ok(getCurrentRunLoop(), 'expected a run-loop');
-        assert.equal(increment, 1);
-        assert.equal(increment2, 2);
-        assert.equal(increment3, 3);
-      }
-
-      function asyncFunction(fn) {
-        fn(2, 3);
-      }
-
-      asyncFunction(bind(asyncCallback, asyncCallback, 1));
-    }
-
-    ['@test [GH#16652] bind throws an error if callback is undefined']() {
-      let assertBindThrows = (msg, ...args) => {
-        expectAssertion(
-          function() {
-            bind(...args);
-          },
-          /could not find a suitable method to bind/,
-          msg
-        );
-      };
-      assertBindThrows('without arguments');
-      assertBindThrows('with one arguments that is not a function', 'myMethod');
-      assertBindThrows(
-        'if second parameter is not a function and not a property in first parameter',
-        Object.create(null),
-        'myMethod'
-      );
-    }
-  }
-);

data/dist/es/@ember/runloop/tests/run_test.js

@@ -1,28 +0,0 @@
-import { run } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'system/run_loop/run_test',
-  class extends AbstractTestCase {
-    ['@test run invokes passed function, returning value'](assert) {
-      let obj = {
-        foo() {
-          return [this.bar, 'FOO'];
-        },
-        bar: 'BAR',
-        checkArgs(arg1, arg2) {
-          return [arg1, this.bar, arg2];
-        },
-      };
-
-      assert.equal(run(() => 'FOO'), 'FOO', 'pass function only');
-      assert.deepEqual(run(obj, obj.foo), ['BAR', 'FOO'], 'pass obj and obj.method');
-      assert.deepEqual(run(obj, 'foo'), ['BAR', 'FOO'], 'pass obj and "method"');
-      assert.deepEqual(
-        run(obj, obj.checkArgs, 'hello', 'world'),
-        ['hello', 'BAR', 'world'],
-        'pass obj, obj.method, and extra arguments'
-      );
-    }
-  }
-);

data/dist/es/@ember/runloop/tests/schedule_test.js

@@ -1,86 +0,0 @@
-import { run, cancel, schedule, getCurrentRunLoop } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'system/run_loop/schedule_test',
-  class extends AbstractTestCase {
-    ['@test scheduling item in queue should defer until finished'](assert) {
-      let cnt = 0;
-
-      run(() => {
-        schedule('actions', () => cnt++);
-        schedule('actions', () => cnt++);
-        assert.equal(cnt, 0, 'should not run action yet');
-      });
-
-      assert.equal(cnt, 2, 'should flush actions now');
-    }
-
-    ['@test a scheduled item can be canceled'](assert) {
-      let hasRan = false;
-
-      run(() => {
-        let cancelId = schedule('actions', () => (hasRan = true));
-        cancel(cancelId);
-      });
-
-      assert.notOk(hasRan, 'should not have ran callback run');
-    }
-
-    ['@test nested runs should queue each phase independently'](assert) {
-      let cnt = 0;
-
-      run(() => {
-        schedule('actions', () => cnt++);
-        assert.equal(cnt, 0, 'should not run action yet');
-
-        run(() => {
-          schedule('actions', () => cnt++);
-        });
-        assert.equal(cnt, 1, 'should not run action yet');
-      });
-
-      assert.equal(cnt, 2, 'should flush actions now');
-    }
-
-    ['@test prior queues should be flushed before moving on to next queue'](assert) {
-      let order = [];
-
-      run(() => {
-        let runLoop = getCurrentRunLoop();
-        assert.ok(runLoop, 'run loop present');
-
-        expectDeprecation(() => {
-          schedule('sync', () => {
-            order.push('sync');
-            assert.equal(runLoop, getCurrentRunLoop(), 'same run loop used');
-          });
-        }, `Scheduling into the 'sync' run loop queue is deprecated.`);
-
-        schedule('actions', () => {
-          order.push('actions');
-          assert.equal(runLoop, getCurrentRunLoop(), 'same run loop used');
-
-          schedule('actions', () => {
-            order.push('actions');
-            assert.equal(runLoop, getCurrentRunLoop(), 'same run loop used');
-          });
-
-          expectDeprecation(() => {
-            schedule('sync', () => {
-              order.push('sync');
-              assert.equal(runLoop, getCurrentRunLoop(), 'same run loop used');
-            });
-          }, `Scheduling into the 'sync' run loop queue is deprecated.`);
-        });
-
-        schedule('destroy', () => {
-          order.push('destroy');
-          assert.equal(runLoop, getCurrentRunLoop(), 'same run loop used');
-        });
-      });
-
-      assert.deepEqual(order, ['sync', 'actions', 'sync', 'actions', 'destroy']);
-    }
-  }
-);

data/dist/es/@ember/runloop/tests/sync_test.js

@@ -1,32 +0,0 @@
-import { run, schedule } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'system/run_loop/sync_test',
-  class extends AbstractTestCase {
-    ['@test sync() will immediately flush the sync queue only'](assert) {
-      let cnt = 0;
-
-      run(() => {
-        function cntup() {
-          cnt++;
-        }
-
-        function syncfunc() {
-          if (++cnt < 5) {
-            expectDeprecation(() => {
-              schedule('sync', syncfunc);
-            }, `Scheduling into the 'sync' run loop queue is deprecated.`);
-          }
-          schedule('actions', cntup);
-        }
-
-        syncfunc();
-
-        assert.equal(cnt, 1, 'should not run action yet');
-      });
-
-      assert.equal(cnt, 10, 'should flush actions now too');
-    }
-  }
-);

data/dist/es/@ember/runloop/tests/unwind_test.js

@@ -1,54 +0,0 @@
-import { run, schedule, getCurrentRunLoop } from '..';
-import EmberError from '@ember/error';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'system/run_loop/unwind_test',
-  class extends AbstractTestCase {
-    ['@test RunLoop unwinds despite unhandled exception'](assert) {
-      let initialRunLoop = getCurrentRunLoop();
-
-      assert.throws(
-        () => {
-          run(() => {
-            schedule('actions', function() {
-              throw new EmberError('boom!');
-            });
-          });
-        },
-        Error,
-        'boom!'
-      );
-
-      // The real danger at this point is that calls to autorun will stick
-      // tasks into the already-dead runloop, which will never get
-      // flushed. I can't easily demonstrate this in a unit test because
-      // autorun explicitly doesn't work in test mode. - ef4
-      assert.equal(
-        getCurrentRunLoop(),
-        initialRunLoop,
-        'Previous run loop should be cleaned up despite exception'
-      );
-    }
-
-    ['@test run unwinds despite unhandled exception'](assert) {
-      var initialRunLoop = getCurrentRunLoop();
-
-      assert.throws(
-        () => {
-          run(function() {
-            throw new EmberError('boom!');
-          });
-        },
-        EmberError,
-        'boom!'
-      );
-
-      assert.equal(
-        getCurrentRunLoop(),
-        initialRunLoop,
-        'Previous run loop should be cleaned up despite exception'
-      );
-    }
-  }
-);

data/dist/es/@ember/service/index.js

@@ -1,57 +0,0 @@
-import { Object as EmberObject } from 'ember-runtime';
-import { InjectedProperty } from 'ember-metal';
-
-/**
- @module @ember/service
- @public
- */
-
-/**
-  Creates a property that lazily looks up a service in the container. There
-  are no restrictions as to what objects a service can be injected into.
-
-  Example:
-
-  ```app/routes/application.js
-  import Route from '@ember/routing/route';
-  import { inject as service } from '@ember/service';
-
-  export default Route.extend({
-    authManager: service('auth'),
-
-    model() {
-      return this.get('authManager').findCurrentUser();
-    }
-  });
-  ```
-
-  This example will create an `authManager` property on the application route
-  that looks up the `auth` service in the container, making it easily
-  accessible in the `model` hook.
-
-  @method inject
-  @static
-  @since 1.10.0
-  @for @ember/service
-  @param {String} name (optional) name of the service to inject, defaults to
-         the property's name
-  @return {Ember.InjectedProperty} injection descriptor instance
-  @public
-*/
-export function inject(name, options) {
-  return new InjectedProperty('service', name, options);
-}
-
-/**
-  @class Service
-  @extends EmberObject
-  @since 1.10.0
-  @public
-*/
-const Service = EmberObject.extend();
-
-Service.reopenClass({
-  isServiceFactory: true,
-});
-
-export default Service;

data/dist/es/@ember/string/index.js

@@ -1,362 +0,0 @@
-/**
-@module @ember/string
-*/
-export { getStrings as _getStrings, setStrings as _setStrings } from './lib/string_registry';
-import { ENV } from 'ember-environment';
-import { Cache } from 'ember-utils';
-import { getString } from './lib/string_registry';
-const STRING_DASHERIZE_REGEXP = /[ _]/g;
-const STRING_DASHERIZE_CACHE = new Cache(1000, key => decamelize(key).replace(STRING_DASHERIZE_REGEXP, '-'));
-const STRING_CAMELIZE_REGEXP_1 = /(\-|\_|\.|\s)+(.)?/g;
-const STRING_CAMELIZE_REGEXP_2 = /(^|\/)([A-Z])/g;
-const CAMELIZE_CACHE = new Cache(1000, key => key
-    .replace(STRING_CAMELIZE_REGEXP_1, (_match, _separator, chr) => (chr ? chr.toUpperCase() : ''))
-    .replace(STRING_CAMELIZE_REGEXP_2, (match /*, separator, chr */) => match.toLowerCase()));
-const STRING_CLASSIFY_REGEXP_1 = /^(\-|_)+(.)?/;
-const STRING_CLASSIFY_REGEXP_2 = /(.)(\-|\_|\.|\s)+(.)?/g;
-const STRING_CLASSIFY_REGEXP_3 = /(^|\/|\.)([a-z])/g;
-const CLASSIFY_CACHE = new Cache(1000, str => {
-    let replace1 = (_match, _separator, chr) => chr ? `_${chr.toUpperCase()}` : '';
-    let replace2 = (_match, initialChar, _separator, chr) => initialChar + (chr ? chr.toUpperCase() : '');
-    let parts = str.split('/');
-    for (let i = 0; i < parts.length; i++) {
-        parts[i] = parts[i]
-            .replace(STRING_CLASSIFY_REGEXP_1, replace1)
-            .replace(STRING_CLASSIFY_REGEXP_2, replace2);
-    }
-    return parts
-        .join('/')
-        .replace(STRING_CLASSIFY_REGEXP_3, (match /*, separator, chr */) => match.toUpperCase());
-});
-const STRING_UNDERSCORE_REGEXP_1 = /([a-z\d])([A-Z]+)/g;
-const STRING_UNDERSCORE_REGEXP_2 = /\-|\s+/g;
-const UNDERSCORE_CACHE = new Cache(1000, str => str
-    .replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2')
-    .replace(STRING_UNDERSCORE_REGEXP_2, '_')
-    .toLowerCase());
-const STRING_CAPITALIZE_REGEXP = /(^|\/)([a-z\u00C0-\u024F])/g;
-const CAPITALIZE_CACHE = new Cache(1000, str => str.replace(STRING_CAPITALIZE_REGEXP, (match /*, separator, chr */) => match.toUpperCase()));
-const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
-const DECAMELIZE_CACHE = new Cache(1000, str => str.replace(STRING_DECAMELIZE_REGEXP, '$1_$2').toLowerCase());
-/**
-  Defines string helper methods including string formatting and localization.
-  Unless `EmberENV.EXTEND_PROTOTYPES.String` is `false` these methods will also be
-  added to the `String.prototype` as well.
-
-  @class String
-  @public
-*/
-function _fmt(str, formats) {
-    // first, replace any ORDERED replacements.
-    let idx = 0; // the current index for non-numerical replacements
-    return str.replace(/%@([0-9]+)?/g, (_s, argIndex) => {
-        let i = argIndex ? parseInt(argIndex, 10) - 1 : idx++;
-        let r = i < formats.length ? formats[i] : undefined;
-        return typeof r === 'string' ? r : r === null ? '(null)' : r === undefined ? '' : '' + r;
-    });
-}
-/**
-  Formats the passed string, but first looks up the string in the localized
-  strings hash. This is a convenient way to localize text.
-
-  Note that it is traditional but not required to prefix localized string
-  keys with an underscore or other character so you can easily identify
-  localized strings.
-
-  ```javascript
-  import { loc } from '@ember/string';
-
-  Ember.STRINGS = {
-    '_Hello World': 'Bonjour le monde',
-    '_Hello %@ %@': 'Bonjour %@ %@'
-  };
-
-  loc("_Hello World");  // 'Bonjour le monde';
-  loc("_Hello %@ %@", ["John", "Smith"]);  // "Bonjour John Smith";
-  ```
-
-  @method loc
-  @param {String} str The string to format
-  @param {Array} formats Optional array of parameters to interpolate into string.
-  @return {String} formatted string
-  @public
-*/
-export function loc(str, formats) {
-    if (!Array.isArray(formats) || arguments.length > 2) {
-        formats = Array.prototype.slice.call(arguments, 1);
-    }
-    str = getString(str) || str;
-    return _fmt(str, formats);
-}
-/**
-  Splits a string into separate units separated by spaces, eliminating any
-  empty strings in the process. This is a convenience method for split that
-  is mostly useful when applied to the `String.prototype`.
-
-  ```javascript
-  import { w } from '@ember/string';
-
-  w("alpha beta gamma").forEach(function(key) {
-    console.log(key);
-  });
-
-  // > alpha
-  // > beta
-  // > gamma
-  ```
-
-  @method w
-  @param {String} str The string to split
-  @return {Array} array containing the split strings
-  @public
-*/
-export function w(str) {
-    return str.split(/\s+/);
-}
-/**
-  Converts a camelized string into all lower case separated by underscores.
-
-  ```javascript
-  'innerHTML'.decamelize();           // 'inner_html'
-  'action_name'.decamelize();        // 'action_name'
-  'css-class-name'.decamelize();     // 'css-class-name'
-  'my favorite items'.decamelize();  // 'my favorite items'
-  ```
-
-  @method decamelize
-  @param {String} str The string to decamelize.
-  @return {String} the decamelized string.
-  @public
-*/
-export function decamelize(str) {
-    return DECAMELIZE_CACHE.get(str);
-}
-/**
-  Replaces underscores, spaces, or camelCase with dashes.
-
-  ```javascript
-  'innerHTML'.dasherize();          // 'inner-html'
-  'action_name'.dasherize();        // 'action-name'
-  'css-class-name'.dasherize();     // 'css-class-name'
-  'my favorite items'.dasherize();  // 'my-favorite-items'
-  'privateDocs/ownerInvoice'.dasherize(); // 'private-docs/owner-invoice'
-  ```
-
-  @method dasherize
-  @param {String} str The string to dasherize.
-  @return {String} the dasherized string.
-  @public
-*/
-export function dasherize(str) {
-    return STRING_DASHERIZE_CACHE.get(str);
-}
-/**
-  Returns the lowerCamelCase form of a string.
-
-  ```javascript
-  'innerHTML'.camelize();          // 'innerHTML'
-  'action_name'.camelize();        // 'actionName'
-  'css-class-name'.camelize();     // 'cssClassName'
-  'my favorite items'.camelize();  // 'myFavoriteItems'
-  'My Favorite Items'.camelize();  // 'myFavoriteItems'
-  'private-docs/owner-invoice'.camelize(); // 'privateDocs/ownerInvoice'
-  ```
-
-  @method camelize
-  @param {String} str The string to camelize.
-  @return {String} the camelized string.
-  @public
-*/
-export function camelize(str) {
-    return CAMELIZE_CACHE.get(str);
-}
-/**
-  Returns the UpperCamelCase form of a string.
-
-  ```javascript
-  'innerHTML'.classify();          // 'InnerHTML'
-  'action_name'.classify();        // 'ActionName'
-  'css-class-name'.classify();     // 'CssClassName'
-  'my favorite items'.classify();  // 'MyFavoriteItems'
-  'private-docs/owner-invoice'.classify(); // 'PrivateDocs/OwnerInvoice'
-  ```
-
-  @method classify
-  @param {String} str the string to classify
-  @return {String} the classified string
-  @public
-*/
-export function classify(str) {
-    return CLASSIFY_CACHE.get(str);
-}
-/**
-  More general than decamelize. Returns the lower\_case\_and\_underscored
-  form of a string.
-
-  ```javascript
-  'innerHTML'.underscore();          // 'inner_html'
-  'action_name'.underscore();        // 'action_name'
-  'css-class-name'.underscore();     // 'css_class_name'
-  'my favorite items'.underscore();  // 'my_favorite_items'
-  'privateDocs/ownerInvoice'.underscore(); // 'private_docs/owner_invoice'
-  ```
-
-  @method underscore
-  @param {String} str The string to underscore.
-  @return {String} the underscored string.
-  @public
-*/
-export function underscore(str) {
-    return UNDERSCORE_CACHE.get(str);
-}
-/**
-  Returns the Capitalized form of a string
-
-  ```javascript
-  'innerHTML'.capitalize()         // 'InnerHTML'
-  'action_name'.capitalize()       // 'Action_name'
-  'css-class-name'.capitalize()    // 'Css-class-name'
-  'my favorite items'.capitalize() // 'My favorite items'
-  'privateDocs/ownerInvoice'.capitalize(); // 'PrivateDocs/ownerInvoice'
-  ```
-
-  @method capitalize
-  @param {String} str The string to capitalize.
-  @return {String} The capitalized string.
-  @public
-*/
-export function capitalize(str) {
-    return CAPITALIZE_CACHE.get(str);
-}
-if (ENV.EXTEND_PROTOTYPES.String) {
-    Object.defineProperties(String.prototype, {
-        /**
-          See [String.w](/api/ember/release/classes/String/methods/w?anchor=w).
-    
-          @method w
-          @for @ember/string
-          @static
-          @private
-        */
-        w: {
-            configurable: true,
-            enumerable: false,
-            writeable: true,
-            value: function () {
-                return w(this);
-            },
-        },
-        /**
-          See [String.loc](/api/ember/release/classes/String/methods/loc?anchor=loc).
-    
-          @method loc
-          @for @ember/string
-          @static
-          @private
-        */
-        loc: {
-            configurable: true,
-            enumerable: false,
-            writeable: true,
-            value: function (...args) {
-                return loc(this, args);
-            },
-        },
-        /**
-          See [String.camelize](/api/ember/release/classes/String/methods/camelize?anchor=camelize).
-    
-          @method camelize
-          @for @ember/string
-          @static
-          @private
-        */
-        camelize: {
-            configurable: true,
-            enumerable: false,
-            writeable: true,
-            value: function () {
-                return camelize(this);
-            },
-        },
-        /**
-          See [String.decamelize](/api/ember/release/classes/String/methods/decamelize?anchor=decamelize).
-    
-          @method decamelize
-          @for @ember/string
-          @static
-          @private
-        */
-        decamelize: {
-            configurable: true,
-            enumerable: false,
-            writeable: true,
-            value: function () {
-                return decamelize(this);
-            },
-        },
-        /**
-          See [String.dasherize](/api/ember/release/classes/String/methods/dasherize?anchor=dasherize).
-    
-          @method dasherize
-          @for @ember/string
-          @static
-          @private
-        */
-        dasherize: {
-            configurable: true,
-            enumerable: false,
-            writeable: true,
-            value: function () {
-                return dasherize(this);
-            },
-        },
-        /**
-          See [String.underscore](/api/ember/release/classes/String/methods/underscore?anchor=underscore).
-    
-          @method underscore
-          @for @ember/string
-          @static
-          @private
-        */
-        underscore: {
-            configurable: true,
-            enumerable: false,
-            writeable: true,
-            value: function () {
-                return underscore(this);
-            },
-        },
-        /**
-          See [String.classify](/api/ember/release/classes/String/methods/classify?anchor=classify).
-    
-          @method classify
-          @for @ember/string
-          @static
-          @private
-        */
-        classify: {
-            configurable: true,
-            enumerable: false,
-            writeable: true,
-            value: function () {
-                return classify(this);
-            },
-        },
-        /**
-          See [String.capitalize](/api/ember/release/classes/String/methods/capitalize?anchor=capitalize).
-    
-          @method capitalize
-          @for @ember/string
-          @static
-          @private
-        */
-        capitalize: {
-            configurable: true,
-            enumerable: false,
-            writeable: true,
-            value: function () {
-                return capitalize(this);
-            },
-        },
-    });
-}