discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@ember/engine/tests/engine_parent_test.js

@@ -1,20 +0,0 @@
-import { getEngineParent, setEngineParent } from '@ember/engine';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'EngineParent',
-  class extends TestCase {
-    ["@test An engine's parent can be set with `setEngineParent` and retrieved with `getEngineParent`"](
-      assert
-    ) {
-      let engine = {};
-      let parent = {};
-
-      assert.strictEqual(getEngineParent(engine), undefined, 'parent has not been set');
-
-      setEngineParent(engine, parent);
-
-      assert.strictEqual(getEngineParent(engine), parent, 'parent has been set');
-    }
-  }
-);

data/dist/es/@ember/engine/tests/engine_test.js

@@ -1,121 +0,0 @@
-import { context } from 'ember-environment';
-import { run } from '@ember/runloop';
-import Engine from '@ember/engine';
-import { Object as EmberObject } from 'ember-runtime';
-import { privatize as P } from 'container';
-import {
-  moduleFor,
-  AbstractTestCase as TestCase,
-  verifyInjection,
-  verifyRegistration,
-} from 'internal-test-helpers';
-
-let engine;
-let originalLookup = context.lookup;
-
-moduleFor(
-  'Engine',
-  class extends TestCase {
-    constructor() {
-      super();
-
-      run(() => {
-        engine = Engine.create();
-        context.lookup = { TestEngine: engine };
-      });
-    }
-
-    teardown() {
-      context.lookup = originalLookup;
-      if (engine) {
-        run(engine, 'destroy');
-        engine = null;
-      }
-    }
-
-    ['@test acts like a namespace'](assert) {
-      engine.Foo = EmberObject.extend();
-      assert.equal(
-        engine.Foo.toString(),
-        'TestEngine.Foo',
-        'Classes pick up their parent namespace'
-      );
-    }
-
-    ['@test builds a registry'](assert) {
-      assert.strictEqual(
-        engine.resolveRegistration('application:main'),
-        engine,
-        `application:main is registered`
-      );
-      assert.deepEqual(
-        engine.registeredOptionsForType('component'),
-        { singleton: false },
-        `optionsForType 'component'`
-      );
-      assert.deepEqual(
-        engine.registeredOptionsForType('view'),
-        { singleton: false },
-        `optionsForType 'view'`
-      );
-      verifyRegistration(assert, engine, 'controller:basic');
-      verifyInjection(assert, engine, 'view', '_viewRegistry', '-view-registry:main');
-      verifyInjection(assert, engine, 'route', '_topLevelViewTemplate', 'template:-outlet');
-      verifyInjection(assert, engine, 'view:-outlet', 'namespace', 'application:main');
-
-      verifyInjection(assert, engine, 'controller', 'target', 'router:main');
-      verifyInjection(assert, engine, 'controller', 'namespace', 'application:main');
-
-      verifyInjection(assert, engine, 'router', '_bucketCache', P`-bucket-cache:main`);
-      verifyInjection(assert, engine, 'route', '_bucketCache', P`-bucket-cache:main`);
-
-      verifyInjection(assert, engine, 'route', '_router', 'router:main');
-
-      verifyRegistration(assert, engine, 'component:-text-field');
-      verifyRegistration(assert, engine, 'component:-text-area');
-      verifyRegistration(assert, engine, 'component:-checkbox');
-      verifyRegistration(assert, engine, 'component:link-to');
-
-      verifyRegistration(assert, engine, 'service:-routing');
-      verifyInjection(assert, engine, 'service:-routing', 'router', 'router:main');
-
-      // DEBUGGING
-      verifyRegistration(assert, engine, 'resolver-for-debugging:main');
-      verifyInjection(
-        assert,
-        engine,
-        'container-debug-adapter:main',
-        'resolver',
-        'resolver-for-debugging:main'
-      );
-      verifyInjection(
-        assert,
-        engine,
-        'data-adapter:main',
-        'containerDebugAdapter',
-        'container-debug-adapter:main'
-      );
-      verifyRegistration(assert, engine, 'container-debug-adapter:main');
-      verifyRegistration(assert, engine, 'component-lookup:main');
-
-      verifyInjection(assert, engine, 'service:-dom-changes', 'document', 'service:-document');
-      verifyInjection(
-        assert,
-        engine,
-        'service:-dom-tree-construction',
-        'document',
-        'service:-document'
-      );
-      verifyRegistration(assert, engine, 'view:-outlet');
-      verifyRegistration(assert, engine, P`template:components/-default`);
-      verifyRegistration(assert, engine, 'template:-outlet');
-      verifyInjection(assert, engine, 'view:-outlet', 'template', 'template:-outlet');
-      verifyInjection(assert, engine, 'template', 'compiler', P`template-compiler:main`);
-      assert.deepEqual(
-        engine.registeredOptionsForType('helper'),
-        { instantiate: false },
-        `optionsForType 'helper'`
-      );
-    }
-  }
-);

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

@@ -1,36 +0,0 @@
-/**
- @module @ember/error
-*/
-function ExtendBuiltin(klass) {
-    function ExtendableBuiltin() {
-        klass.apply(this, arguments);
-    }
-    ExtendableBuiltin.prototype = Object.create(klass.prototype);
-    ExtendableBuiltin.prototype.constructor = ExtendableBuiltin;
-    return ExtendableBuiltin;
-}
-/**
-  A subclass of the JavaScript Error object for use in Ember.
-
-  @class EmberError
-  @extends Error
-  @constructor
-  @public
-*/
-export default class EmberError extends ExtendBuiltin(Error) {
-    constructor(message) {
-        super();
-        if (!(this instanceof EmberError)) {
-            return new EmberError(message);
-        }
-        let error = Error.call(this, message);
-        this.stack = error.stack;
-        this.description = error.description;
-        this.fileName = error.fileName;
-        this.lineNumber = error.lineNumber;
-        this.message = error.message;
-        this.name = error.name;
-        this.number = error.number;
-        this.code = error.code;
-    }
-}

data/dist/es/@ember/error/tests/index_test.js

@@ -1,19 +0,0 @@
-import EmberError from '@ember/error';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember Error Throwing',
-  class extends TestCase {
-    ['@test new EmberError displays provided message'](assert) {
-      assert.throws(
-        () => {
-          throw new EmberError('A Message');
-        },
-        function(e) {
-          return e.message === 'A Message';
-        },
-        'the assigned message was displayed'
-      );
-    }
-  }
-);

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

@@ -1,240 +0,0 @@
-/* eslint no-console:off */
-/* global console */
-import { EMBER_IMPROVED_INSTRUMENTATION } from '@ember/canary-features';
-import { ENV } from 'ember-environment';
-/**
-@module @ember/instrumentation
-@private
-*/
-/**
-  The purpose of the Ember Instrumentation module is
-  to provide efficient, general-purpose instrumentation
-  for Ember.
-
-  Subscribe to a listener by using `subscribe`:
-
-  ```javascript
-  import { subscribe } from '@ember/instrumentation';
-
-  subscribe("render", {
-    before(name, timestamp, payload) {
-
-    },
-
-    after(name, timestamp, payload) {
-
-    }
-  });
-  ```
-
-  If you return a value from the `before` callback, that same
-  value will be passed as a fourth parameter to the `after`
-  callback.
-
-  Instrument a block of code by using `instrument`:
-
-  ```javascript
-  import { instrument } from '@ember/instrumentation';
-
-  instrument("render.handlebars", payload, function() {
-    // rendering logic
-  }, binding);
-  ```
-
-  Event names passed to `instrument` are namespaced
-  by periods, from more general to more specific. Subscribers
-  can listen for events by whatever level of granularity they
-  are interested in.
-
-  In the above example, the event is `render.handlebars`,
-  and the subscriber listened for all events beginning with
-  `render`. It would receive callbacks for events named
-  `render`, `render.handlebars`, `render.container`, or
-  even `render.handlebars.layout`.
-
-  @class Instrumentation
-  @static
-  @private
-*/
-export let subscribers = [];
-let cache = {};
-function populateListeners(name) {
-    let listeners = [];
-    let subscriber;
-    for (let i = 0; i < subscribers.length; i++) {
-        subscriber = subscribers[i];
-        if (subscriber.regex.test(name)) {
-            listeners.push(subscriber.object);
-        }
-    }
-    cache[name] = listeners;
-    return listeners;
-}
-const time = (() => {
-    let perf = 'undefined' !== typeof window ? window.performance || {} : {};
-    let fn = perf.now || perf.mozNow || perf.webkitNow || perf.msNow || perf.oNow;
-    // fn.bind will be available in all the browsers that support the advanced window.performance... ;-)
-    return fn
-        ? fn.bind(perf)
-        : () => {
-            return +new Date();
-        };
-})();
-export function instrument(name, p1, p2, p3) {
-    let payload;
-    let callback;
-    let binding;
-    if (arguments.length <= 3 && typeof p1 === 'function') {
-        payload = {};
-        callback = p1;
-        binding = p2;
-    }
-    else {
-        payload = (p1 || {});
-        callback = p2;
-        binding = p3;
-    }
-    if (subscribers.length === 0) {
-        return callback.call(binding);
-    }
-    let finalizer = _instrumentStart(name, () => payload);
-    if (finalizer) {
-        return withFinalizer(callback, finalizer, payload, binding);
-    }
-    else {
-        return callback.call(binding);
-    }
-}
-let flaggedInstrument;
-if (EMBER_IMPROVED_INSTRUMENTATION) {
-    flaggedInstrument = instrument;
-}
-else {
-    flaggedInstrument = (_name, _payload, callback) => callback();
-}
-export { flaggedInstrument };
-function withFinalizer(callback, finalizer, payload, binding) {
-    let result;
-    try {
-        result = callback.call(binding);
-    }
-    catch (e) {
-        payload.exception = e;
-        result = payload;
-    }
-    finally {
-        finalizer();
-    }
-    return result;
-}
-function NOOP() { }
-export function _instrumentStart(name, _payload, _payloadParam) {
-    if (subscribers.length === 0) {
-        return NOOP;
-    }
-    let listeners = cache[name];
-    if (!listeners) {
-        listeners = populateListeners(name);
-    }
-    if (listeners.length === 0) {
-        return NOOP;
-    }
-    let payload = _payload(_payloadParam);
-    let STRUCTURED_PROFILE = ENV.STRUCTURED_PROFILE;
-    let timeName;
-    if (STRUCTURED_PROFILE) {
-        timeName = `${name}: ${payload.object}`;
-        console.time(timeName);
-    }
-    let beforeValues = new Array(listeners.length);
-    let i;
-    let listener;
-    let timestamp = time();
-    for (i = 0; i < listeners.length; i++) {
-        listener = listeners[i];
-        beforeValues[i] = listener.before(name, timestamp, payload);
-    }
-    return function _instrumentEnd() {
-        let i;
-        let listener;
-        let timestamp = time();
-        for (i = 0; i < listeners.length; i++) {
-            listener = listeners[i];
-            if (typeof listener.after === 'function') {
-                listener.after(name, timestamp, payload, beforeValues[i]);
-            }
-        }
-        if (STRUCTURED_PROFILE) {
-            console.timeEnd(timeName);
-        }
-    };
-}
-/**
-  Subscribes to a particular event or instrumented block of code.
-
-  @method subscribe
-  @for @ember/instrumentation
-  @static
-
-  @param {String} [pattern] Namespaced event name.
-  @param {Object} [object] Before and After hooks.
-
-  @return {Subscriber}
-  @private
-*/
-export function subscribe(pattern, object) {
-    let paths = pattern.split('.');
-    let path;
-    let regexes = [];
-    for (let i = 0; i < paths.length; i++) {
-        path = paths[i];
-        if (path === '*') {
-            regexes.push('[^\\.]*');
-        }
-        else {
-            regexes.push(path);
-        }
-    }
-    let regex = regexes.join('\\.');
-    regex = `${regex}(\\..*)?`;
-    let subscriber = {
-        pattern,
-        regex: new RegExp(`^${regex}$`),
-        object,
-    };
-    subscribers.push(subscriber);
-    cache = {};
-    return subscriber;
-}
-/**
-  Unsubscribes from a particular event or instrumented block of code.
-
-  @method unsubscribe
-  @for @ember/instrumentation
-  @static
-
-  @param {Object} [subscriber]
-  @private
-*/
-export function unsubscribe(subscriber) {
-    let index = 0;
-    for (let i = 0; i < subscribers.length; i++) {
-        if (subscribers[i] === subscriber) {
-            index = i;
-        }
-    }
-    subscribers.splice(index, 1);
-    cache = {};
-}
-/**
-  Resets `Instrumentation` by flushing list of subscribers.
-
-  @method reset
-  @for @ember/instrumentation
-  @static
-  @private
-*/
-export function reset() {
-    subscribers.length = 0;
-    cache = {};
-}

data/dist/es/@ember/instrumentation/tests/index-test.js

@@ -1,214 +0,0 @@
-import { instrument, subscribe, unsubscribe, reset } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember Instrumentation',
-  class extends AbstractTestCase {
-    afterEach() {
-      reset();
-    }
-
-    ['@test execute block even if no listeners'](assert) {
-      let result = instrument('render', {}, function() {
-        return 'hello';
-      });
-      assert.equal(result, 'hello', 'called block');
-    }
-
-    ['@test subscribing to a simple path receives the listener'](assert) {
-      assert.expect(12);
-
-      let sentPayload = {};
-      let count = 0;
-
-      subscribe('render', {
-        before(name, timestamp, payload) {
-          if (count === 0) {
-            assert.strictEqual(name, 'render');
-          } else {
-            assert.strictEqual(name, 'render.handlebars');
-          }
-
-          assert.ok(typeof timestamp === 'number');
-          assert.strictEqual(payload, sentPayload);
-        },
-
-        after(name, timestamp, payload) {
-          if (count === 0) {
-            assert.strictEqual(name, 'render');
-          } else {
-            assert.strictEqual(name, 'render.handlebars');
-          }
-
-          assert.ok(typeof timestamp === 'number');
-          assert.strictEqual(payload, sentPayload);
-
-          count++;
-        },
-      });
-
-      instrument('render', sentPayload, function() {});
-
-      instrument('render.handlebars', sentPayload, function() {});
-    }
-
-    ['@test returning a value from the before callback passes it to the after callback'](assert) {
-      assert.expect(2);
-
-      let passthru1 = {};
-      let passthru2 = {};
-
-      subscribe('render', {
-        before() {
-          return passthru1;
-        },
-        after(name, timestamp, payload, beforeValue) {
-          assert.strictEqual(beforeValue, passthru1);
-        },
-      });
-
-      subscribe('render', {
-        before() {
-          return passthru2;
-        },
-        after(name, timestamp, payload, beforeValue) {
-          assert.strictEqual(beforeValue, passthru2);
-        },
-      });
-
-      instrument('render', null, function() {});
-    }
-
-    ['@test instrument with 2 args (name, callback) no payload'](assert) {
-      assert.expect(1);
-
-      subscribe('render', {
-        before(name, timestamp, payload) {
-          assert.deepEqual(payload, {});
-        },
-        after() {},
-      });
-
-      instrument('render', function() {});
-    }
-
-    ['@test instrument with 3 args (name, callback, binding) no payload'](assert) {
-      assert.expect(2);
-
-      let binding = {};
-      subscribe('render', {
-        before(name, timestamp, payload) {
-          assert.deepEqual(payload, {});
-        },
-        after() {},
-      });
-
-      instrument(
-        'render',
-        function() {
-          assert.deepEqual(this, binding);
-        },
-        binding
-      );
-    }
-
-    ['@test instrument with 3 args (name, payload, callback) with payload'](assert) {
-      assert.expect(1);
-
-      let expectedPayload = { hi: 1 };
-      subscribe('render', {
-        before(name, timestamp, payload) {
-          assert.deepEqual(payload, expectedPayload);
-        },
-        after() {},
-      });
-
-      instrument('render', expectedPayload, function() {});
-    }
-
-    ['@test instrument with 4 args (name, payload, callback, binding) with payload'](assert) {
-      assert.expect(2);
-
-      let expectedPayload = { hi: 1 };
-      let binding = {};
-      subscribe('render', {
-        before(name, timestamp, payload) {
-          assert.deepEqual(payload, expectedPayload);
-        },
-        after() {},
-      });
-
-      instrument(
-        'render',
-        expectedPayload,
-        function() {
-          assert.deepEqual(this, binding);
-        },
-        binding
-      );
-    }
-
-    ['@test raising an exception in the instrumentation attaches it to the payload'](assert) {
-      assert.expect(2);
-
-      let error = new Error('Instrumentation');
-
-      subscribe('render', {
-        before() {},
-        after(name, timestamp, payload) {
-          assert.strictEqual(payload.exception, error);
-        },
-      });
-
-      subscribe('render', {
-        before() {},
-        after(name, timestamp, payload) {
-          assert.strictEqual(payload.exception, error);
-        },
-      });
-
-      instrument('render.handlebars', null, function() {
-        throw error;
-      });
-    }
-
-    ['@test it is possible to add a new subscriber after the first instrument'](assert) {
-      instrument('render.handlebars', null, function() {});
-
-      subscribe('render', {
-        before() {
-          assert.ok(true, 'Before callback was called');
-        },
-        after() {
-          assert.ok(true, 'After callback was called');
-        },
-      });
-
-      instrument('render.handlebars', null, function() {});
-    }
-
-    ['@test it is possible to remove a subscriber'](assert) {
-      assert.expect(4);
-
-      let count = 0;
-
-      let subscriber = subscribe('render', {
-        before() {
-          assert.equal(count, 0);
-          assert.ok(true, 'Before callback was called');
-        },
-        after() {
-          assert.equal(count, 0);
-          assert.ok(true, 'After callback was called');
-          count++;
-        },
-      });
-
-      instrument('render.handlebars', null, function() {});
-
-      unsubscribe(subscriber);
-
-      instrument('render.handlebars', null, function() {});
-    }
-  }
-);