discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember/tests/homepage_example_test.js

@@ -1,47 +0,0 @@
-import { Route } from 'ember-routing';
-import { computed } from 'ember-metal';
-import { Object as EmberObject, A as emberA } from 'ember-runtime';
-
-import { moduleFor, ApplicationTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'The example renders correctly',
-  class extends ApplicationTestCase {
-    ['@test Render index template into application outlet'](assert) {
-      this.addTemplate('application', '{{outlet}}');
-      this.addTemplate(
-        'index',
-        '<h1>People</h1><ul>{{#each model as |person|}}<li>Hello, <b>{{person.fullName}}</b>!</li>{{/each}}</ul>'
-      );
-
-      let Person = EmberObject.extend({
-        firstName: null,
-        lastName: null,
-        fullName: computed('firstName', 'lastName', function() {
-          return `${this.get('firstName')} ${this.get('lastName')}`;
-        }),
-      });
-
-      this.add(
-        'route:index',
-        Route.extend({
-          model() {
-            return emberA([
-              Person.create({ firstName: 'Tom', lastName: 'Dale' }),
-              Person.create({ firstName: 'Yehuda', lastName: 'Katz' }),
-            ]);
-          },
-        })
-      );
-
-      return this.visit('/').then(() => {
-        let $ = this.$();
-
-        assert.equal($.findAll('h1').text(), 'People');
-        assert.equal($.findAll('li').length, 2);
-        assert.equal($.findAll('li:nth-of-type(1)').text(), 'Hello, Tom Dale!');
-        assert.equal($.findAll('li:nth-of-type(2)').text(), 'Hello, Yehuda Katz!');
-      });
-    }
-  }
-);

data/dist/es/ember/tests/integration/multiple-app-test.js

@@ -1,101 +0,0 @@
-import { moduleFor, ApplicationTestCase } from 'internal-test-helpers';
-import Application from '@ember/application';
-import { Component } from 'ember-glimmer';
-import { getOwner } from 'ember-owner';
-import { assign } from '@ember/polyfills';
-import { resolve } from 'rsvp';
-
-moduleFor(
-  'View Integration',
-  class extends ApplicationTestCase {
-    constructor() {
-      document.getElementById('qunit-fixture').innerHTML = `
-      <div id="one"></div>
-      <div id="two"></div>
-    `;
-      super();
-      this.runTask(() => {
-        this.createSecondApplication();
-      });
-    }
-
-    get applicationOptions() {
-      return assign(super.applicationOptions, {
-        rootElement: '#one',
-        router: null,
-      });
-    }
-
-    createSecondApplication(options) {
-      let { applicationOptions } = this;
-      let secondApplicationOptions = { rootElement: '#two' };
-      let myOptions = assign(applicationOptions, secondApplicationOptions, options);
-      this.secondApp = Application.create(myOptions);
-      this.secondResolver = this.secondApp.__registry__.resolver;
-      return this.secondApp;
-    }
-
-    teardown() {
-      super.teardown();
-
-      if (this.secondApp) {
-        this.runTask(() => {
-          this.secondApp.destroy();
-        });
-      }
-    }
-
-    addFactoriesToResolver(actions, resolver) {
-      resolver.add(
-        'component:special-button',
-        Component.extend({
-          actions: {
-            doStuff() {
-              let rootElement = getOwner(this).application.rootElement;
-              actions.push(rootElement);
-            },
-          },
-        })
-      );
-
-      resolver.add(
-        'template:index',
-        this.compile(
-          `
-        <h1>Node 1</h1>{{special-button}}
-      `,
-          {
-            moduleName: 'my-app/templates/index.hbs',
-          }
-        )
-      );
-      resolver.add(
-        'template:components/special-button',
-        this.compile(
-          `
-        <button class='do-stuff' {{action 'doStuff'}}>Button</button>
-      `,
-          {
-            moduleName: 'my-app/templates/components/special-button.hbs',
-          }
-        )
-      );
-    }
-
-    [`@test booting multiple applications can properly handle events`](assert) {
-      let actions = [];
-      this.addFactoriesToResolver(actions, this.resolver);
-      this.addFactoriesToResolver(actions, this.secondResolver);
-
-      return resolve()
-        .then(() => this.application.visit('/'))
-        .then(() => this.secondApp.visit('/'))
-        .then(() => {
-          document.querySelector('#two .do-stuff').click();
-          document.querySelector('#one .do-stuff').click();
-
-          assert.deepEqual(actions, ['#two', '#one']);
-        });
-    }
-  }
-);

data/dist/es/ember/tests/production_build_test.js

@@ -1,34 +0,0 @@
-import { DEBUG } from '@glimmer/env';
-import { assert as emberAssert, runInDebug } from '@ember/debug';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'production builds',
-  class extends AbstractTestCase {
-    ['@test assert does not throw in production builds'](assert) {
-      if (!DEBUG) {
-        assert.expect(1);
-
-        try {
-          emberAssert('Should not throw');
-          assert.ok(true, 'Ember.assert did not throw');
-        } catch (e) {
-          assert.ok(false, `Expected assert not to throw but it did: ${e.message}`);
-        }
-      } else {
-        assert.expect(0);
-      }
-    }
-
-    ['@test runInDebug does not run the callback in production builds'](assert) {
-      if (!DEBUG) {
-        let fired = false;
-        runInDebug(() => (fired = true));
-
-        assert.equal(fired, false, 'runInDebug callback should not be ran');
-      } else {
-        assert.expect(0);
-      }
-    }
-  }
-);

data/dist/es/ember/tests/reexports_test.js

@@ -1,307 +0,0 @@
-import Ember from '../index';
-import { FEATURES } from '@ember/canary-features';
-import { confirmExport } from 'internal-test-helpers';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-import { jQueryDisabled } from '../../ember-views';
-
-moduleFor(
-  'ember reexports',
-  class extends AbstractTestCase {
-    [`@test Ember exports correctly`](assert) {
-      allExports.forEach(reexport => {
-        let [path, moduleId, exportName] = reexport;
-
-        // default path === exportName if none present
-        if (!exportName) {
-          exportName = path;
-        }
-
-        confirmExport(Ember, assert, path, moduleId, exportName, `Ember.${path} exports correctly`);
-      });
-    }
-
-    ['@test Ember.String.isHTMLSafe exports correctly'](assert) {
-      confirmExport(Ember, assert, 'String.isHTMLSafe', 'ember-glimmer', 'isHTMLSafe');
-    }
-
-    ['@test Ember.EXTEND_PROTOTYPES is present (but deprecated)'](assert) {
-      expectDeprecation(() => {
-        assert.strictEqual(
-          Ember.ENV.EXTEND_PROTOTYPES,
-          Ember.EXTEND_PROTOTYPES,
-          'Ember.EXTEND_PROTOTYPES exists'
-        );
-      }, /EXTEND_PROTOTYPES is deprecated/);
-    }
-
-    '@test Ember.FEATURES is exported'(assert) {
-      for (let feature in FEATURES) {
-        assert.equal(
-          Ember.FEATURES[feature],
-          FEATURES[feature],
-          'Ember.FEATURES contains ${feature} with correct value'
-        );
-      }
-    }
-  }
-);
-
-let allExports = [
-  // ember-environment
-  ['ENV', 'ember-environment', { get: 'getENV' }],
-  ['lookup', 'ember-environment', { get: 'getLookup', set: 'setLookup' }],
-
-  // ember-utils
-  ['getOwner', '@ember/application', 'getOwner'],
-  ['setOwner', '@ember/application', 'setOwner'],
-  ['assign', '@ember/polyfills'],
-  ['GUID_KEY', 'ember-utils'],
-  ['uuid', 'ember-utils'],
-  ['generateGuid', 'ember-utils'],
-  ['guidFor', 'ember-utils'],
-  ['inspect', 'ember-utils'],
-  ['makeArray', 'ember-utils'],
-  ['canInvoke', 'ember-utils'],
-  ['tryInvoke', 'ember-utils'],
-  ['wrap', 'ember-utils'],
-  ['NAME_KEY', 'ember-utils'],
-
-  // container
-  ['Registry', 'container', 'Registry'],
-  ['Container', 'container', 'Container'],
-
-  // @ember/debug
-  ['deprecateFunc', '@ember/debug'],
-  ['deprecate', '@ember/debug'],
-  ['assert', '@ember/debug'],
-  ['warn', '@ember/debug'],
-  ['debug', '@ember/debug'],
-  ['runInDebug', '@ember/debug'],
-  ['Debug.registerDeprecationHandler', '@ember/debug', 'registerDeprecationHandler'],
-  ['Debug.registerWarnHandler', '@ember/debug', 'registerWarnHandler'],
-  ['Error', '@ember/error', 'default'],
-
-  // ember-metal
-  ['computed', 'ember-metal', '_globalsComputed'],
-  ['computed.alias', 'ember-metal', 'alias'],
-  ['ComputedProperty', 'ember-metal'],
-  ['cacheFor', 'ember-metal', 'getCachedValueFor'],
-  ['merge', '@ember/polyfills'],
-  ['instrument', '@ember/instrumentation'],
-  ['subscribe', '@ember/instrumentation', 'subscribe'],
-  ['Instrumentation.instrument', '@ember/instrumentation', 'instrument'],
-  ['Instrumentation.subscribe', '@ember/instrumentation', 'subscribe'],
-  ['Instrumentation.unsubscribe', '@ember/instrumentation', 'unsubscribe'],
-  ['Instrumentation.reset', '@ember/instrumentation', 'reset'],
-  ['testing', '@ember/debug', { get: 'isTesting', set: 'setTesting' }],
-  ['onerror', 'ember-error-handling', { get: 'getOnerror', set: 'setOnerror' }],
-  ['FEATURES.isEnabled', '@ember/canary-features', 'isEnabled'],
-  ['meta', 'ember-meta'],
-  ['get', 'ember-metal'],
-  ['set', 'ember-metal'],
-  ['_getPath', 'ember-metal'],
-  ['getWithDefault', 'ember-metal'],
-  ['trySet', 'ember-metal'],
-  ['_Cache', 'ember-utils', 'Cache'],
-  ['on', 'ember-metal'],
-  ['addListener', 'ember-metal'],
-  ['removeListener', 'ember-metal'],
-  ['sendEvent', 'ember-metal'],
-  ['hasListeners', 'ember-metal'],
-  ['isNone', 'ember-metal'],
-  ['isEmpty', 'ember-metal'],
-  ['isBlank', 'ember-metal'],
-  ['isPresent', 'ember-metal'],
-  ['_Backburner', 'backburner', 'default'],
-  ['run', '@ember/runloop', '_globalsRun'],
-  ['run.backburner', '@ember/runloop', 'backburner'],
-  ['run.begin', '@ember/runloop', 'begin'],
-  ['run.bind', '@ember/runloop', 'bind'],
-  ['run.cancel', '@ember/runloop', 'cancel'],
-  ['run.debounce', '@ember/runloop', 'debounce'],
-  ['run.end', '@ember/runloop', 'end'],
-  ['run.hasScheduledTimers', '@ember/runloop', 'hasScheduledTimers'],
-  ['run.join', '@ember/runloop', 'join'],
-  ['run.later', '@ember/runloop', 'later'],
-  ['run.next', '@ember/runloop', 'next'],
-  ['run.once', '@ember/runloop', 'once'],
-  ['run.schedule', '@ember/runloop', 'schedule'],
-  ['run.scheduleOnce', '@ember/runloop', 'scheduleOnce'],
-  ['run.throttle', '@ember/runloop', 'throttle'],
-  ['run.currentRunLoop', '@ember/runloop', { get: 'getCurrentRunLoop' }],
-  ['run.cancelTimers', '@ember/runloop', 'cancelTimers'],
-  ['propertyWillChange', 'ember-metal'],
-  ['propertyDidChange', 'ember-metal'],
-  ['notifyPropertyChange', 'ember-metal'],
-  ['overrideChains', 'ember-metal'],
-  ['beginPropertyChanges', 'ember-metal'],
-  ['endPropertyChanges', 'ember-metal'],
-  ['changeProperties', 'ember-metal'],
-  ['platform.defineProperty', null, { value: true }],
-  ['platform.hasPropertyAccessors', null, { value: true }],
-  ['defineProperty', 'ember-metal'],
-  ['watchKey', 'ember-metal'],
-  ['unwatchKey', 'ember-metal'],
-  ['removeChainWatcher', 'ember-metal'],
-  ['_ChainNode', 'ember-metal', 'ChainNode'],
-  ['finishChains', 'ember-metal'],
-  ['watchPath', 'ember-metal'],
-  ['unwatchPath', 'ember-metal'],
-  ['watch', 'ember-metal'],
-  ['isWatching', 'ember-metal'],
-  ['unwatch', 'ember-metal'],
-  ['destroy', 'ember-meta', 'deleteMeta'],
-  ['libraries', 'ember-metal'],
-  ['OrderedSet', '@ember/map/lib/ordered-set', 'default'],
-  ['Map', '@ember/map', 'default'],
-  ['MapWithDefault', '@ember/map/with-default', 'default'],
-  ['getProperties', 'ember-metal'],
-  ['setProperties', 'ember-metal'],
-  ['expandProperties', 'ember-metal'],
-  ['addObserver', 'ember-metal'],
-  ['removeObserver', 'ember-metal'],
-  ['aliasMethod', 'ember-metal'],
-  ['observer', 'ember-metal'],
-  ['mixin', 'ember-metal'],
-  ['Mixin', 'ember-metal'],
-
-  // ember-console
-  ['Logger', 'ember-console', 'default'],
-
-  // ember-views
-  !jQueryDisabled && ['$', 'ember-views', 'jQuery'],
-  ['ViewUtils.isSimpleClick', 'ember-views', 'isSimpleClick'],
-  ['ViewUtils.getViewElement', 'ember-views', 'getViewElement'],
-  ['ViewUtils.getViewBounds', 'ember-views', 'getViewBounds'],
-  ['ViewUtils.getViewClientRects', 'ember-views', 'getViewClientRects'],
-  ['ViewUtils.getViewBoundingClientRect', 'ember-views', 'getViewBoundingClientRect'],
-  ['ViewUtils.getRootViews', 'ember-views', 'getRootViews'],
-  ['ViewUtils.getChildViews', 'ember-views', 'getChildViews'],
-  ['ViewUtils.isSerializationFirstNode', 'ember-glimmer', 'isSerializationFirstNode'],
-  ['TextSupport', 'ember-views'],
-  ['ComponentLookup', 'ember-views'],
-  ['EventDispatcher', 'ember-views'],
-
-  // ember-glimmer
-  ['Component', 'ember-glimmer', 'Component'],
-  ['Helper', 'ember-glimmer', 'Helper'],
-  ['Helper.helper', 'ember-glimmer', 'helper'],
-  ['Checkbox', 'ember-glimmer', 'Checkbox'],
-  ['LinkComponent', 'ember-glimmer', 'LinkComponent'],
-  ['TextArea', 'ember-glimmer', 'TextArea'],
-  ['TextField', 'ember-glimmer', 'TextField'],
-  ['TEMPLATES', 'ember-glimmer', { get: 'getTemplates', set: 'setTemplates' }],
-  ['Handlebars.template', 'ember-glimmer', 'template'],
-  ['HTMLBars.template', 'ember-glimmer', 'template'],
-  ['Handlebars.Utils.escapeExpression', 'ember-glimmer', 'escapeExpression'],
-  ['String.htmlSafe', 'ember-glimmer', 'htmlSafe'],
-  ['_setComponentManager', 'ember-glimmer', 'setComponentManager'],
-  ['_componentManagerCapabilities', 'ember-glimmer', 'capabilities'],
-
-  // ember-runtime
-  ['A', 'ember-runtime'],
-  ['_RegistryProxyMixin', 'ember-runtime', 'RegistryProxyMixin'],
-  ['_ContainerProxyMixin', 'ember-runtime', 'ContainerProxyMixin'],
-  ['Object', 'ember-runtime'],
-  ['String.loc', '@ember/string', 'loc'],
-  ['String.w', '@ember/string', 'w'],
-  ['String.dasherize', '@ember/string', 'dasherize'],
-  ['String.decamelize', '@ember/string', 'decamelize'],
-  ['String.camelize', '@ember/string', 'camelize'],
-  ['String.classify', '@ember/string', 'classify'],
-  ['String.underscore', '@ember/string', 'underscore'],
-  ['String.capitalize', '@ember/string', 'capitalize'],
-  ['compare', 'ember-runtime'],
-  ['copy', 'ember-runtime'],
-  ['isEqual', 'ember-runtime'],
-  ['inject.controller', '@ember/controller', 'inject'],
-  ['inject.service', '@ember/service', 'inject'],
-  ['Array', 'ember-runtime'],
-  ['Comparable', 'ember-runtime'],
-  ['Namespace', 'ember-runtime'],
-  ['Enumerable', 'ember-runtime'],
-  ['ArrayProxy', 'ember-runtime'],
-  ['ObjectProxy', 'ember-runtime'],
-  ['ActionHandler', 'ember-runtime'],
-  ['CoreObject', 'ember-runtime'],
-  ['NativeArray', 'ember-runtime'],
-  ['Copyable', 'ember-runtime'],
-  ['MutableEnumerable', 'ember-runtime'],
-  ['MutableArray', 'ember-runtime'],
-  ['TargetActionSupport', 'ember-runtime'],
-  ['Evented', 'ember-runtime'],
-  ['PromiseProxyMixin', 'ember-runtime'],
-  ['Observable', 'ember-runtime'],
-  ['typeOf', 'ember-runtime'],
-  ['isArray', 'ember-runtime'],
-  ['Object', 'ember-runtime'],
-  ['onLoad', '@ember/application'],
-  ['runLoadHooks', '@ember/application'],
-  ['Controller', '@ember/controller', 'default'],
-  ['ControllerMixin', '@ember/controller/lib/controller_mixin', 'default'],
-  ['Service', '@ember/service', 'default'],
-  ['_ProxyMixin', 'ember-runtime'],
-  ['RSVP', 'ember-runtime'],
-  ['STRINGS', '@ember/string', { get: '_getStrings', set: '_setStrings' }],
-  [
-    'BOOTED',
-    'ember-metal',
-    { get: 'isNamespaceSearchDisabled', set: 'setNamespaceSearchDisabled' },
-  ],
-  ['computed.empty', '@ember/object/computed', 'empty'],
-  ['computed.notEmpty', '@ember/object/computed', 'notEmpty'],
-  ['computed.none', '@ember/object/computed', 'none'],
-  ['computed.not', '@ember/object/computed', 'not'],
-  ['computed.bool', '@ember/object/computed', 'bool'],
-  ['computed.match', '@ember/object/computed', 'match'],
-  ['computed.equal', '@ember/object/computed', 'equal'],
-  ['computed.gt', '@ember/object/computed', 'gt'],
-  ['computed.gte', '@ember/object/computed', 'gte'],
-  ['computed.lt', '@ember/object/computed', 'lt'],
-  ['computed.lte', '@ember/object/computed', 'lte'],
-  ['computed.oneWay', '@ember/object/computed', 'oneWay'],
-  ['computed.reads', '@ember/object/computed', 'oneWay'],
-  ['computed.readOnly', '@ember/object/computed', 'readOnly'],
-  ['computed.deprecatingAlias', '@ember/object/computed', 'deprecatingAlias'],
-  ['computed.and', '@ember/object/computed', 'and'],
-  ['computed.or', '@ember/object/computed', 'or'],
-  ['computed.sum', '@ember/object/computed', 'sum'],
-  ['computed.min', '@ember/object/computed', 'min'],
-  ['computed.max', '@ember/object/computed', 'max'],
-  ['computed.map', '@ember/object/computed', 'map'],
-  ['computed.sort', '@ember/object/computed', 'sort'],
-  ['computed.setDiff', '@ember/object/computed', 'setDiff'],
-  ['computed.mapBy', '@ember/object/computed', 'mapBy'],
-  ['computed.filter', '@ember/object/computed', 'filter'],
-  ['computed.filterBy', '@ember/object/computed', 'filterBy'],
-  ['computed.uniq', '@ember/object/computed', 'uniq'],
-  ['computed.uniqBy', '@ember/object/computed', 'uniqBy'],
-  ['computed.union', '@ember/object/computed', 'union'],
-  ['computed.intersect', '@ember/object/computed', 'intersect'],
-  ['computed.collect', '@ember/object/computed', 'collect'],
-
-  // ember-routing
-  ['Location', 'ember-routing'],
-  ['AutoLocation', 'ember-routing'],
-  ['HashLocation', 'ember-routing'],
-  ['HistoryLocation', 'ember-routing'],
-  ['NoneLocation', 'ember-routing'],
-  ['controllerFor', 'ember-routing'],
-  ['generateControllerFactory', 'ember-routing'],
-  ['generateController', 'ember-routing'],
-  ['RouterDSL', 'ember-routing'],
-  ['Router', 'ember-routing'],
-  ['Route', 'ember-routing'],
-
-  // ember-application
-  ['Application', '@ember/application', 'default'],
-  ['ApplicationInstance', '@ember/application/instance', 'default'],
-  ['Engine', '@ember/engine', 'default'],
-  ['EngineInstance', '@ember/engine/instance', 'default'],
-  ['Resolver', '@ember/application/globals-resolver', 'default'],
-  ['DefaultResolver', '@ember/application/globals-resolver', 'default'],
-
-  // ember-extension-support
-  ['DataAdapter', 'ember-extension-support'],
-  ['ContainerDebugAdapter', 'ember-extension-support'],
-].filter(Boolean);