discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@ember/application/lib/lazy_load.js

@@ -1,69 +0,0 @@
-/*globals CustomEvent */
-
-import { ENV } from 'ember-environment';
-import { window } from 'ember-browser-environment';
-
-/**
-  @module @ember/application
-*/
-
-const loadHooks = ENV.EMBER_LOAD_HOOKS || {};
-const loaded = {};
-export let _loaded = loaded;
-
-/**
-  Detects when a specific package of Ember (e.g. 'Application')
-  has fully loaded and is available for extension.
-
-  The provided `callback` will be called with the `name` passed
-  resolved from a string into the object:
-
-  ``` javascript
-  import { onLoad } from '@ember/application';
-
-  onLoad('Ember.Application' function(hbars) {
-    hbars.registerHelper(...);
-  });
-  ```
-
-  @method onLoad
-  @static
-  @for @ember/application
-  @param name {String} name of hook
-  @param callback {Function} callback to be called
-  @private
-*/
-export function onLoad(name, callback) {
-  let object = loaded[name];
-
-  loadHooks[name] = loadHooks[name] || [];
-  loadHooks[name].push(callback);
-
-  if (object) {
-    callback(object);
-  }
-}
-
-/**
-  Called when an Ember.js package (e.g Application) has finished
-  loading. Triggers any callbacks registered for this event.
-
-  @method runLoadHooks
-  @static
-  @for @ember/application
-  @param name {String} name of hook
-  @param object {Object} object to pass to callbacks
-  @private
-*/
-export function runLoadHooks(name, object) {
-  loaded[name] = object;
-
-  if (window && typeof CustomEvent === 'function') {
-    let event = new CustomEvent(name, { detail: object, name });
-    window.dispatchEvent(event);
-  }
-
-  if (loadHooks[name]) {
-    loadHooks[name].forEach(callback => callback(object));
-  }
-}

data/dist/es/@ember/application/lib/validate-type.js

@@ -1,24 +0,0 @@
-import { assert } from '@ember/debug';
-
-const VALIDATED_TYPES = {
-  route: ['assert', 'isRouteFactory', 'Ember.Route'],
-  component: ['deprecate', 'isComponentFactory', 'Ember.Component'],
-  view: ['deprecate', 'isViewFactory', 'Ember.View'],
-  service: ['deprecate', 'isServiceFactory', 'Ember.Service'],
-};
-
-export default function validateType(resolvedType, parsedName) {
-  let validationAttributes = VALIDATED_TYPES[parsedName.type];
-
-  if (!validationAttributes) {
-    return;
-  }
-
-  let [, factoryFlag, expectedType] = validationAttributes;
-
-  assert(
-    `Expected ${parsedName.fullName} to resolve to an ${expectedType} but ` +
-      `instead it was ${resolvedType}.`,
-    !!resolvedType[factoryFlag]
-  );
-}

data/dist/es/@ember/application/tests/application_instance_test.js

@@ -1,230 +0,0 @@
-import Engine from '@ember/engine';
-import Application from '@ember/application';
-import ApplicationInstance from '@ember/application/instance';
-import { run } from '@ember/runloop';
-import { privatize as P } from 'container';
-import { factory } from 'internal-test-helpers';
-import { Object as EmberObject } from 'ember-runtime';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-import { getDebugFunction, setDebugFunction } from '@ember/debug';
-
-const originalDebug = getDebugFunction('debug');
-const noop = function() {};
-
-let application, appInstance;
-
-moduleFor(
-  'ApplicationInstance',
-  class extends TestCase {
-    constructor() {
-      setDebugFunction('debug', noop);
-      super();
-
-      document.getElementById('qunit-fixture').innerHTML = `
-      <div id='one'><div id='one-child'>HI</div></div><div id='two'>HI</div>
-    `;
-      application = run(() => Application.create({ rootElement: '#one', router: null }));
-    }
-
-    teardown() {
-      setDebugFunction('debug', originalDebug);
-      if (appInstance) {
-        run(appInstance, 'destroy');
-        appInstance = null;
-      }
-
-      if (application) {
-        run(application, 'destroy');
-        application = null;
-      }
-
-      document.getElementById('qunit-fixture').innerHTML = '';
-    }
-
-    ['@test an application instance can be created based upon an application'](assert) {
-      appInstance = run(() => ApplicationInstance.create({ application }));
-
-      assert.ok(appInstance, 'instance should be created');
-      assert.equal(appInstance.application, application, 'application should be set to parent');
-    }
-
-    ['@test customEvents added to the application before setupEventDispatcher'](assert) {
-      assert.expect(1);
-
-      appInstance = run(() => ApplicationInstance.create({ application }));
-      appInstance.setupRegistry();
-
-      application.customEvents = {
-        awesome: 'sauce',
-      };
-
-      let eventDispatcher = appInstance.lookup('event_dispatcher:main');
-      eventDispatcher.setup = function(events) {
-        assert.equal(events.awesome, 'sauce');
-      };
-
-      appInstance.setupEventDispatcher();
-    }
-
-    ['@test customEvents added to the application before setupEventDispatcher'](assert) {
-      assert.expect(1);
-
-      appInstance = run(() => ApplicationInstance.create({ application }));
-      appInstance.setupRegistry();
-
-      application.customEvents = {
-        awesome: 'sauce',
-      };
-
-      let eventDispatcher = appInstance.lookup('event_dispatcher:main');
-      eventDispatcher.setup = function(events) {
-        assert.equal(events.awesome, 'sauce');
-      };
-
-      appInstance.setupEventDispatcher();
-    }
-
-    ['@test customEvents added to the application instance before setupEventDispatcher'](assert) {
-      assert.expect(1);
-
-      appInstance = run(() => ApplicationInstance.create({ application }));
-      appInstance.setupRegistry();
-
-      appInstance.customEvents = {
-        awesome: 'sauce',
-      };
-
-      let eventDispatcher = appInstance.lookup('event_dispatcher:main');
-      eventDispatcher.setup = function(events) {
-        assert.equal(events.awesome, 'sauce');
-      };
-
-      appInstance.setupEventDispatcher();
-    }
-
-    ['@test unregistering a factory clears all cached instances of that factory'](assert) {
-      assert.expect(5);
-
-      appInstance = run(() => ApplicationInstance.create({ application }));
-
-      let PostController1 = factory();
-      let PostController2 = factory();
-
-      appInstance.register('controller:post', PostController1);
-
-      let postController1 = appInstance.lookup('controller:post');
-      let postController1Factory = appInstance.factoryFor('controller:post');
-      assert.ok(postController1 instanceof PostController1, 'precond - lookup creates instance');
-      assert.equal(
-        PostController1,
-        postController1Factory.class,
-        'precond - factoryFor().class matches'
-      );
-
-      appInstance.unregister('controller:post');
-      appInstance.register('controller:post', PostController2);
-
-      let postController2 = appInstance.lookup('controller:post');
-      let postController2Factory = appInstance.factoryFor('controller:post');
-      assert.ok(postController2 instanceof PostController2, 'lookup creates instance');
-      assert.equal(PostController2, postController2Factory.class, 'factoryFor().class matches');
-
-      assert.notStrictEqual(
-        postController1,
-        postController2,
-        'lookup creates a brand new instance, because the previous one was reset'
-      );
-    }
-
-    ['@skip unregistering a factory clears caches with source of that factory'](assert) {
-      assert.expect(1);
-
-      appInstance = run(() => ApplicationInstance.create({ application }));
-
-      let PostController1 = factory();
-      let PostController2 = factory();
-
-      appInstance.register('controller:post', PostController1);
-
-      appInstance.lookup('controller:post');
-      let postControllerLookupWithSource = appInstance.lookup('controller:post', {
-        source: 'doesnt-even-matter',
-      });
-
-      appInstance.unregister('controller:post');
-      appInstance.register('controller:post', PostController2);
-
-      // The cache that is source-specific is not cleared
-      assert.ok(
-        postControllerLookupWithSource !==
-          appInstance.lookup('controller:post', {
-            source: 'doesnt-even-matter',
-          }),
-        'lookup with source creates a new instance'
-      );
-    }
-
-    ['@test can build and boot a registered engine'](assert) {
-      assert.expect(11);
-
-      let ChatEngine = Engine.extend();
-      let chatEngineInstance;
-
-      application.register('engine:chat', ChatEngine);
-
-      run(() => {
-        appInstance = ApplicationInstance.create({ application });
-        appInstance.setupRegistry();
-        chatEngineInstance = appInstance.buildChildEngineInstance('chat');
-      });
-
-      return chatEngineInstance.boot().then(() => {
-        assert.ok(true, 'boot successful');
-
-        let registrations = ['route:basic', 'service:-routing', 'service:-glimmer-environment'];
-
-        registrations.forEach(key => {
-          assert.strictEqual(
-            chatEngineInstance.resolveRegistration(key),
-            appInstance.resolveRegistration(key),
-            `Engine and parent app share registrations for '${key}'`
-          );
-        });
-
-        let singletons = [
-          'router:main',
-          P`-bucket-cache:main`,
-          '-view-registry:main',
-          '-environment:main',
-          'service:-document',
-          'event_dispatcher:main',
-        ];
-
-        let env = appInstance.lookup('-environment:main');
-        singletons.push(env.isInteractive ? 'renderer:-dom' : 'renderer:-inert');
-
-        singletons.forEach(key => {
-          assert.strictEqual(
-            chatEngineInstance.lookup(key),
-            appInstance.lookup(key),
-            `Engine and parent app share singleton '${key}'`
-          );
-        });
-      });
-    }
-
-    ['@test can build a registry via ApplicationInstance.setupRegistry() -- simulates ember-test-helpers'](
-      assert
-    ) {
-      let namespace = EmberObject.create({
-        Resolver: { create: function() {} },
-      });
-
-      let registry = Application.buildRegistry(namespace);
-
-      ApplicationInstance.setupRegistry(registry);
-
-      assert.equal(registry.resolve('service:-document'), document);
-    }
-  }
-);

data/dist/es/@ember/application/tests/application_test.js

@@ -1,470 +0,0 @@
-/*globals EmberDev */
-import VERSION from 'ember/version';
-import { ENV, context } from 'ember-environment';
-import { libraries } from 'ember-metal';
-import { getDebugFunction, setDebugFunction } from '@ember/debug';
-import Application from '..';
-import { Router, NoneLocation, Route as EmberRoute } from 'ember-routing';
-import { jQueryDisabled, jQuery } from 'ember-views';
-import { _loaded } from '@ember/application';
-import Controller from '@ember/controller';
-import { Object as EmberObject } from 'ember-runtime';
-import { setTemplates } from 'ember-glimmer';
-import { privatize as P } from 'container';
-import { assign } from '@ember/polyfills';
-import {
-  moduleFor,
-  ApplicationTestCase,
-  AbstractTestCase,
-  AutobootApplicationTestCase,
-  DefaultResolverApplicationTestCase,
-  verifyInjection,
-  verifyRegistration,
-} from 'internal-test-helpers';
-import { run } from '@ember/runloop';
-
-moduleFor(
-  'Application, autobooting multiple apps',
-  class extends ApplicationTestCase {
-    get fixture() {
-      return `
-      <div id="one">
-        <div id="one-child">HI</div>
-      </div>
-      <div id="two">HI</div>
-    `;
-    }
-
-    get applicationOptions() {
-      return assign(super.applicationOptions, {
-        rootElement: '#one',
-        router: null,
-        autoboot: true,
-      });
-    }
-
-    createSecondApplication(options) {
-      let myOptions = assign(this.applicationOptions, options);
-      return (this.secondApp = Application.create(myOptions));
-    }
-
-    teardown() {
-      super.teardown();
-
-      if (this.secondApp) {
-        this.runTask(() => this.secondApp.destroy());
-      }
-    }
-
-    [`@test you can make a new application in a non-overlapping element`](assert) {
-      let app = this.runTask(() =>
-        this.createSecondApplication({
-          rootElement: '#two',
-        })
-      );
-
-      this.runTask(() => app.destroy());
-      assert.ok(true, 'should not raise');
-    }
-
-    [`@test you cannot make a new application that is a parent of an existing application`]() {
-      expectAssertion(() => {
-        this.runTask(() =>
-          this.createSecondApplication({
-            rootElement: this.applicationOptions.rootElement,
-          })
-        );
-      });
-    }
-
-    [`@test you cannot make a new application that is a descendant of an existing application`]() {
-      expectAssertion(() => {
-        this.runTask(() =>
-          this.createSecondApplication({
-            rootElement: '#one-child',
-          })
-        );
-      });
-    }
-
-    [`@test you cannot make a new application that is a duplicate of an existing application`]() {
-      expectAssertion(() => {
-        this.runTask(() =>
-          this.createSecondApplication({
-            rootElement: '#one',
-          })
-        );
-      });
-    }
-
-    [`@test you cannot make two default applications without a rootElement error`]() {
-      expectAssertion(() => {
-        this.runTask(() => this.createSecondApplication());
-      });
-    }
-  }
-);
-
-moduleFor(
-  'Application',
-  class extends ApplicationTestCase {
-    [`@test builds a registry`](assert) {
-      let { application } = this;
-      assert.strictEqual(
-        application.resolveRegistration('application:main'),
-        application,
-        `application:main is registered`
-      );
-      assert.deepEqual(
-        application.registeredOptionsForType('component'),
-        { singleton: false },
-        `optionsForType 'component'`
-      );
-      assert.deepEqual(
-        application.registeredOptionsForType('view'),
-        { singleton: false },
-        `optionsForType 'view'`
-      );
-
-      verifyRegistration(assert, application, 'controller:basic');
-      verifyRegistration(assert, application, '-view-registry:main');
-      verifyInjection(assert, application, 'view', '_viewRegistry', '-view-registry:main');
-      verifyInjection(assert, application, 'route', '_topLevelViewTemplate', 'template:-outlet');
-      verifyRegistration(assert, application, 'route:basic');
-      verifyRegistration(assert, application, 'event_dispatcher:main');
-      verifyInjection(assert, application, 'router:main', 'namespace', 'application:main');
-      verifyInjection(assert, application, 'view:-outlet', 'namespace', 'application:main');
-
-      verifyRegistration(assert, application, 'location:auto');
-      verifyRegistration(assert, application, 'location:hash');
-      verifyRegistration(assert, application, 'location:history');
-      verifyRegistration(assert, application, 'location:none');
-
-      verifyInjection(assert, application, 'controller', 'target', 'router:main');
-      verifyInjection(assert, application, 'controller', 'namespace', 'application:main');
-
-      verifyRegistration(assert, application, P`-bucket-cache:main`);
-      verifyInjection(assert, application, 'router', '_bucketCache', P`-bucket-cache:main`);
-      verifyInjection(assert, application, 'route', '_bucketCache', P`-bucket-cache:main`);
-
-      verifyInjection(assert, application, 'route', '_router', 'router:main');
-
-      verifyRegistration(assert, application, 'component:-text-field');
-      verifyRegistration(assert, application, 'component:-text-area');
-      verifyRegistration(assert, application, 'component:-checkbox');
-      verifyRegistration(assert, application, 'component:link-to');
-
-      verifyRegistration(assert, application, 'service:-routing');
-      verifyInjection(assert, application, 'service:-routing', 'router', 'router:main');
-
-      // DEBUGGING
-      verifyRegistration(assert, application, 'resolver-for-debugging:main');
-      verifyInjection(
-        assert,
-        application,
-        'container-debug-adapter:main',
-        'resolver',
-        'resolver-for-debugging:main'
-      );
-      verifyInjection(
-        assert,
-        application,
-        'data-adapter:main',
-        'containerDebugAdapter',
-        'container-debug-adapter:main'
-      );
-      verifyRegistration(assert, application, 'container-debug-adapter:main');
-      verifyRegistration(assert, application, 'component-lookup:main');
-
-      verifyRegistration(assert, application, 'service:-glimmer-environment');
-      verifyRegistration(assert, application, 'service:-dom-changes');
-      verifyRegistration(assert, application, 'service:-dom-tree-construction');
-      verifyInjection(
-        assert,
-        application,
-        'service:-glimmer-environment',
-        'appendOperations',
-        'service:-dom-tree-construction'
-      );
-      verifyInjection(
-        assert,
-        application,
-        'service:-glimmer-environment',
-        'updateOperations',
-        'service:-dom-changes'
-      );
-      verifyInjection(assert, application, 'renderer', 'env', 'service:-glimmer-environment');
-      verifyRegistration(assert, application, 'view:-outlet');
-      verifyRegistration(assert, application, 'renderer:-dom');
-      verifyRegistration(assert, application, 'renderer:-inert');
-      verifyRegistration(assert, application, P`template:components/-default`);
-      verifyRegistration(assert, application, 'template:-outlet');
-      verifyInjection(assert, application, 'view:-outlet', 'template', 'template:-outlet');
-      verifyInjection(assert, application, 'template', 'compiler', P`template-compiler:main`);
-
-      assert.deepEqual(
-        application.registeredOptionsForType('helper'),
-        { instantiate: false },
-        `optionsForType 'helper'`
-      );
-    }
-  }
-);
-
-moduleFor(
-  'Application, default resolver with autoboot',
-  class extends DefaultResolverApplicationTestCase {
-    constructor() {
-      super(...arguments);
-      this.originalLookup = context.lookup;
-    }
-
-    teardown() {
-      context.lookup = this.originalLookup;
-      super.teardown();
-      setTemplates({});
-    }
-
-    get applicationOptions() {
-      return assign(super.applicationOptions, {
-        autoboot: true,
-      });
-    }
-
-    [`@test acts like a namespace`](assert) {
-      this.application = this.runTask(() => this.createApplication());
-      let Foo = (this.application.Foo = EmberObject.extend());
-      assert.equal(Foo.toString(), 'TestApp.Foo', 'Classes pick up their parent namespace');
-    }
-
-    [`@test can specify custom router`](assert) {
-      let MyRouter = Router.extend();
-      this.runTask(() => {
-        this.createApplication();
-        this.application.Router = MyRouter;
-      });
-
-      assert.ok(
-        this.application.__deprecatedInstance__.lookup('router:main') instanceof MyRouter,
-        'application resolved the correct router'
-      );
-    }
-
-    [`@test Minimal Application initialized with just an application template`]() {
-      this.setupFixture('<script type="text/x-handlebars">Hello World</script>');
-      this.runTask(() => this.createApplication());
-      this.assertInnerHTML('Hello World');
-    }
-  }
-);
-
-moduleFor(
-  'Application, autobooting',
-  class extends AutobootApplicationTestCase {
-    constructor() {
-      super(...arguments);
-      this.originalLogVersion = ENV.LOG_VERSION;
-      this.originalDebug = getDebugFunction('debug');
-      this.originalWarn = getDebugFunction('warn');
-    }
-
-    teardown() {
-      setDebugFunction('warn', this.originalWarn);
-      setDebugFunction('debug', this.originalDebug);
-      ENV.LOG_VERSION = this.originalLogVersion;
-      super.teardown();
-    }
-
-    [`@test initialized application goes to initial route`]() {
-      this.runTask(() => {
-        this.createApplication();
-        this.addTemplate('application', '{{outlet}}');
-        this.addTemplate('index', '<h1>Hi from index</h1>');
-      });
-
-      this.assertText('Hi from index');
-    }
-
-    [`@test ready hook is called before routing begins`](assert) {
-      assert.expect(2);
-
-      this.runTask(() => {
-        function registerRoute(application, name, callback) {
-          let route = EmberRoute.extend({
-            activate: callback,
-          });
-
-          application.register('route:' + name, route);
-        }
-
-        let MyApplication = Application.extend({
-          ready() {
-            registerRoute(this, 'index', () => {
-              assert.ok(true, 'last-minute route is activated');
-            });
-          },
-        });
-
-        let app = this.createApplication({}, MyApplication);
-
-        registerRoute(app, 'application', () => assert.ok(true, 'normal route is activated'));
-      });
-    }
-
-    [`@test initialize application via initialize call`](assert) {
-      this.runTask(() => this.createApplication());
-      // This is not a public way to access the container; we just
-      // need to make some assertions about the created router
-      let router = this.applicationInstance.lookup('router:main');
-      assert.equal(router instanceof Router, true, 'Router was set from initialize call');
-      assert.equal(
-        router.location instanceof NoneLocation,
-        true,
-        'Location was set from location implementation name'
-      );
-    }
-
-    [`@test initialize application with stateManager via initialize call from Router class`](
-      assert
-    ) {
-      this.runTask(() => {
-        this.createApplication();
-        this.addTemplate('application', '<h1>Hello!</h1>');
-      });
-      // This is not a public way to access the container; we just
-      // need to make some assertions about the created router
-      let router = this.application.__deprecatedInstance__.lookup('router:main');
-      assert.equal(router instanceof Router, true, 'Router was set from initialize call');
-      this.assertText('Hello!');
-    }
-
-    [`@test Application Controller backs the appplication template`]() {
-      this.runTask(() => {
-        this.createApplication();
-        this.addTemplate('application', '<h1>{{greeting}}</h1>');
-        this.add(
-          'controller:application',
-          Controller.extend({
-            greeting: 'Hello!',
-          })
-        );
-      });
-      this.assertText('Hello!');
-    }
-
-    [`@test enable log of libraries with an ENV var`](assert) {
-      if (EmberDev && EmberDev.runningProdBuild) {
-        assert.ok(true, 'Logging does not occur in production builds');
-        return;
-      }
-
-      let messages = [];
-
-      ENV.LOG_VERSION = true;
-
-      setDebugFunction('debug', message => messages.push(message));
-
-      libraries.register('my-lib', '2.0.0a');
-
-      this.runTask(() => this.createApplication());
-
-      assert.equal(messages[1], 'Ember  : ' + VERSION);
-      if (jQueryDisabled) {
-        assert.equal(messages[2], 'my-lib : ' + '2.0.0a');
-      } else {
-        assert.equal(messages[2], 'jQuery : ' + jQuery().jquery);
-        assert.equal(messages[3], 'my-lib : ' + '2.0.0a');
-      }
-
-      libraries.deRegister('my-lib');
-    }
-
-    [`@test disable log of version of libraries with an ENV var`](assert) {
-      let logged = false;
-
-      ENV.LOG_VERSION = false;
-
-      setDebugFunction('debug', () => (logged = true));
-
-      this.runTask(() => this.createApplication());
-
-      assert.ok(!logged, 'library version logging skipped');
-    }
-
-    [`@test can resolve custom router`](assert) {
-      let CustomRouter = Router.extend();
-
-      this.runTask(() => {
-        this.createApplication();
-        this.add('router:main', CustomRouter);
-      });
-
-      assert.ok(
-        this.application.__deprecatedInstance__.lookup('router:main') instanceof CustomRouter,
-        'application resolved the correct router'
-      );
-    }
-
-    [`@test does not leak itself in onLoad._loaded`](assert) {
-      assert.equal(_loaded.application, undefined);
-      this.runTask(() => this.createApplication());
-      assert.equal(_loaded.application, this.application);
-      this.runTask(() => this.application.destroy());
-      assert.equal(_loaded.application, undefined);
-    }
-
-    [`@test can build a registry via Application.buildRegistry() --- simulates ember-test-helpers`](
-      assert
-    ) {
-      let namespace = EmberObject.create({
-        Resolver: { create: function() {} },
-      });
-
-      let registry = Application.buildRegistry(namespace);
-
-      assert.equal(registry.resolve('application:main'), namespace);
-    }
-  }
-);
-
-moduleFor(
-  'Application#buildRegistry',
-  class extends AbstractTestCase {
-    [`@test can build a registry via Application.buildRegistry() --- simulates ember-test-helpers`](
-      assert
-    ) {
-      let namespace = EmberObject.create({
-        Resolver: { create() {} },
-      });
-
-      let registry = Application.buildRegistry(namespace);
-
-      assert.equal(registry.resolve('application:main'), namespace);
-    }
-  }
-);
-
-moduleFor(
-  'Application - instance tracking',
-  class extends ApplicationTestCase {
-    ['@test tracks built instance'](assert) {
-      let instance = this.application.buildInstance();
-      run(() => {
-        this.application.destroy();
-      });
-
-      assert.ok(instance.isDestroyed, 'instance was destroyed');
-    }
-
-    ['@test tracks built instances'](assert) {
-      let instanceA = this.application.buildInstance();
-      let instanceB = this.application.buildInstance();
-      run(() => {
-        this.application.destroy();
-      });
-
-      assert.ok(instanceA.isDestroyed, 'instanceA was destroyed');
-      assert.ok(instanceB.isDestroyed, 'instanceB was destroyed');
-    }
-  }
-);