discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-template-compiler/tests/system/dasherize-component-name-test.js

@@ -1,19 +0,0 @@
-import COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE from '../../lib/system/dasherize-component-name';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'dasherize-component-name',
-  class extends AbstractTestCase {
-    ['@test names are correctly dasherized'](assert) {
-      assert.equal(COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get('Foo'), 'foo');
-      assert.equal(COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get('foo-bar'), 'foo-bar');
-      assert.equal(COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get('FooBar'), 'foo-bar');
-      assert.equal(COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get('XBlah'), 'x-blah');
-      assert.equal(COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get('X-Blah'), 'x-blah');
-      assert.equal(COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get('Foo::BarBaz'), 'foo::bar-baz');
-      assert.equal(COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get('Foo::Bar-Baz'), 'foo::bar-baz');
-      assert.equal(COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get('Foo@BarBaz'), 'foo@bar-baz');
-      assert.equal(COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get('Foo@Bar-Baz'), 'foo@bar-baz');
-    }
-  }
-);

data/dist/es/ember-testing/index.js

@@ -1,10 +0,0 @@
-export { default as Test } from './lib/test';
-export { default as Adapter } from './lib/adapters/adapter';
-export { default as setupForTesting } from './lib/setup_for_testing';
-export { default as QUnitAdapter } from './lib/adapters/qunit';
-
-import './lib/support'; // to handle various edge cases
-import './lib/ext/application';
-import './lib/ext/rsvp'; // setup RSVP + run loop integration
-import './lib/helpers'; // adds helpers to helpers object in Test
-import './lib/initializers'; // to setup initializer

data/dist/es/ember-testing/lib/adapters/adapter.js

@@ -1,58 +0,0 @@
-import { Object as EmberObject } from 'ember-runtime';
-
-function K() {
-  return this;
-}
-
-/**
- @module @ember/test
-*/
-
-/**
-  The primary purpose of this class is to create hooks that can be implemented
-  by an adapter for various test frameworks.
-
-  @class TestAdapter
-  @public
-*/
-export default EmberObject.extend({
-  /**
-    This callback will be called whenever an async operation is about to start.
-
-    Override this to call your framework's methods that handle async
-    operations.
-
-    @public
-    @method asyncStart
-  */
-  asyncStart: K,
-
-  /**
-    This callback will be called whenever an async operation has completed.
-
-    @public
-    @method asyncEnd
-  */
-  asyncEnd: K,
-
-  /**
-    Override this method with your testing framework's false assertion.
-    This function is called whenever an exception occurs causing the testing
-    promise to fail.
-
-    QUnit example:
-
-    ```javascript
-      exception: function(error) {
-        ok(false, error);
-      };
-    ```
-
-    @public
-    @method exception
-    @param {String} error The exception to be raised.
-  */
-  exception(error) {
-    throw error;
-  },
-});

data/dist/es/ember-testing/lib/adapters/qunit.js

@@ -1,47 +0,0 @@
-/* globals QUnit */
-
-import { inspect } from 'ember-utils';
-import Adapter from './adapter';
-/**
-   @module ember
-*/
-/**
-  This class implements the methods defined by TestAdapter for the
-  QUnit testing framework.
-
-  @class QUnitAdapter
-  @namespace Ember.Test
-  @extends TestAdapter
-  @public
-*/
-export default Adapter.extend({
-  init() {
-    this.doneCallbacks = [];
-  },
-
-  asyncStart() {
-    if (typeof QUnit.stop === 'function') {
-      // very old QUnit version
-      QUnit.stop();
-    } else {
-      this.doneCallbacks.push(QUnit.config.current ? QUnit.config.current.assert.async() : null);
-    }
-  },
-  asyncEnd() {
-    // checking for QUnit.stop here (even though we _need_ QUnit.start) because
-    // QUnit.start() still exists in QUnit 2.x (it just throws an error when calling
-    // inside a test context)
-    if (typeof QUnit.stop === 'function') {
-      QUnit.start();
-    } else {
-      let done = this.doneCallbacks.pop();
-      // This can be null if asyncStart() was called outside of a test
-      if (done) {
-        done();
-      }
-    }
-  },
-  exception(error) {
-    QUnit.config.current.assert.ok(false, inspect(error));
-  },
-});

data/dist/es/ember-testing/lib/events.js

@@ -1,136 +0,0 @@
-import { run } from '@ember/runloop';
-import { assign } from '@ember/polyfills';
-import isFormControl from './helpers/-is-form-control';
-
-const DEFAULT_EVENT_OPTIONS = { canBubble: true, cancelable: true };
-const KEYBOARD_EVENT_TYPES = ['keydown', 'keypress', 'keyup'];
-const MOUSE_EVENT_TYPES = [
-  'click',
-  'mousedown',
-  'mouseup',
-  'dblclick',
-  'mouseenter',
-  'mouseleave',
-  'mousemove',
-  'mouseout',
-  'mouseover',
-];
-
-export function focus(el) {
-  if (!el) {
-    return;
-  }
-  if (el.isContentEditable || isFormControl(el)) {
-    let type = el.getAttribute('type');
-    if (type !== 'checkbox' && type !== 'radio' && type !== 'hidden') {
-      run(null, function() {
-        let browserIsNotFocused = document.hasFocus && !document.hasFocus();
-
-        // makes `document.activeElement` be `element`. If the browser is focused, it also fires a focus event
-        el.focus();
-
-        // Firefox does not trigger the `focusin` event if the window
-        // does not have focus. If the document does not have focus then
-        // fire `focusin` event as well.
-        if (browserIsNotFocused) {
-          // if the browser is not focused the previous `el.focus()` didn't fire an event, so we simulate it
-          fireEvent(el, 'focus', {
-            bubbles: false,
-          });
-
-          fireEvent(el, 'focusin');
-        }
-      });
-    }
-  }
-}
-
-export function fireEvent(element, type, options = {}) {
-  if (!element) {
-    return;
-  }
-  let event;
-  if (KEYBOARD_EVENT_TYPES.indexOf(type) > -1) {
-    event = buildKeyboardEvent(type, options);
-  } else if (MOUSE_EVENT_TYPES.indexOf(type) > -1) {
-    let rect = element.getBoundingClientRect();
-    let x = rect.left + 1;
-    let y = rect.top + 1;
-    let simulatedCoordinates = {
-      screenX: x + 5,
-      screenY: y + 95,
-      clientX: x,
-      clientY: y,
-    };
-    event = buildMouseEvent(type, assign(simulatedCoordinates, options));
-  } else {
-    event = buildBasicEvent(type, options);
-  }
-  element.dispatchEvent(event);
-}
-
-function buildBasicEvent(type, options = {}) {
-  let event = document.createEvent('Events');
-
-  // Event.bubbles is read only
-  let bubbles = options.bubbles !== undefined ? options.bubbles : true;
-  let cancelable = options.cancelable !== undefined ? options.cancelable : true;
-
-  delete options.bubbles;
-  delete options.cancelable;
-
-  event.initEvent(type, bubbles, cancelable);
-  assign(event, options);
-  return event;
-}
-
-function buildMouseEvent(type, options = {}) {
-  let event;
-  try {
-    event = document.createEvent('MouseEvents');
-    let eventOpts = assign({}, DEFAULT_EVENT_OPTIONS, options);
-    event.initMouseEvent(
-      type,
-      eventOpts.canBubble,
-      eventOpts.cancelable,
-      window,
-      eventOpts.detail,
-      eventOpts.screenX,
-      eventOpts.screenY,
-      eventOpts.clientX,
-      eventOpts.clientY,
-      eventOpts.ctrlKey,
-      eventOpts.altKey,
-      eventOpts.shiftKey,
-      eventOpts.metaKey,
-      eventOpts.button,
-      eventOpts.relatedTarget
-    );
-  } catch (e) {
-    event = buildBasicEvent(type, options);
-  }
-  return event;
-}
-
-function buildKeyboardEvent(type, options = {}) {
-  let event;
-  try {
-    event = document.createEvent('KeyEvents');
-    let eventOpts = assign({}, DEFAULT_EVENT_OPTIONS, options);
-    event.initKeyEvent(
-      type,
-      eventOpts.canBubble,
-      eventOpts.cancelable,
-      window,
-      eventOpts.ctrlKey,
-      eventOpts.altKey,
-      eventOpts.shiftKey,
-      eventOpts.metaKey,
-      eventOpts.keyCode,
-      eventOpts.charCode
-    );
-  } catch (e) {
-    event = buildBasicEvent(type, options);
-  }
-  return event;
-}

data/dist/es/ember-testing/lib/ext/application.js

@@ -1,191 +0,0 @@
-import EmberApplication from '@ember/application';
-import setupForTesting from '../setup_for_testing';
-import { helpers } from '../test/helpers';
-import TestPromise, { resolve, getLastPromise } from '../test/promise';
-import run from '../test/run';
-import { invokeInjectHelpersCallbacks } from '../test/on_inject_helpers';
-import { asyncStart, asyncEnd } from '../test/adapter';
-
-EmberApplication.reopen({
-  /**
-   This property contains the testing helpers for the current application. These
-   are created once you call `injectTestHelpers` on your `Application`
-   instance. The included helpers are also available on the `window` object by
-   default, but can be used from this object on the individual application also.
-
-    @property testHelpers
-    @type {Object}
-    @default {}
-    @public
-  */
-  testHelpers: {},
-
-  /**
-   This property will contain the original methods that were registered
-   on the `helperContainer` before `injectTestHelpers` is called.
-
-   When `removeTestHelpers` is called, these methods are restored to the
-   `helperContainer`.
-
-    @property originalMethods
-    @type {Object}
-    @default {}
-    @private
-    @since 1.3.0
-  */
-  originalMethods: {},
-
-  /**
-  This property indicates whether or not this application is currently in
-  testing mode. This is set when `setupForTesting` is called on the current
-  application.
-
-  @property testing
-  @type {Boolean}
-  @default false
-  @since 1.3.0
-  @public
-  */
-  testing: false,
-
-  /**
-    This hook defers the readiness of the application, so that you can start
-    the app when your tests are ready to run. It also sets the router's
-    location to 'none', so that the window's location will not be modified
-    (preventing both accidental leaking of state between tests and interference
-    with your testing framework). `setupForTesting` should only be called after
-    setting a custom `router` class (for example `App.Router = Router.extend(`).
-
-    Example:
-
-    ```
-    App.setupForTesting();
-    ```
-
-    @method setupForTesting
-    @public
-  */
-  setupForTesting() {
-    setupForTesting();
-
-    this.testing = true;
-
-    this.resolveRegistration('router:main').reopen({
-      location: 'none',
-    });
-  },
-
-  /**
-    This will be used as the container to inject the test helpers into. By
-    default the helpers are injected into `window`.
-
-    @property helperContainer
-    @type {Object} The object to be used for test helpers.
-    @default window
-    @since 1.2.0
-    @private
-  */
-  helperContainer: null,
-
-  /**
-    This injects the test helpers into the `helperContainer` object. If an object is provided
-    it will be used as the helperContainer. If `helperContainer` is not set it will default
-    to `window`. If a function of the same name has already been defined it will be cached
-    (so that it can be reset if the helper is removed with `unregisterHelper` or
-    `removeTestHelpers`).
-
-    Any callbacks registered with `onInjectHelpers` will be called once the
-    helpers have been injected.
-
-    Example:
-    ```
-    App.injectTestHelpers();
-    ```
-
-    @method injectTestHelpers
-    @public
-  */
-  injectTestHelpers(helperContainer) {
-    if (helperContainer) {
-      this.helperContainer = helperContainer;
-    } else {
-      this.helperContainer = window;
-    }
-
-    this.reopen({
-      willDestroy() {
-        this._super(...arguments);
-        this.removeTestHelpers();
-      },
-    });
-
-    this.testHelpers = {};
-    for (let name in helpers) {
-      this.originalMethods[name] = this.helperContainer[name];
-      this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
-      protoWrap(TestPromise.prototype, name, helper(this, name), helpers[name].meta.wait);
-    }
-
-    invokeInjectHelpersCallbacks(this);
-  },
-
-  /**
-    This removes all helpers that have been registered, and resets and functions
-    that were overridden by the helpers.
-
-    Example:
-
-    ```javascript
-    App.removeTestHelpers();
-    ```
-
-    @public
-    @method removeTestHelpers
-  */
-  removeTestHelpers() {
-    if (!this.helperContainer) {
-      return;
-    }
-
-    for (let name in helpers) {
-      this.helperContainer[name] = this.originalMethods[name];
-      delete TestPromise.prototype[name];
-      delete this.testHelpers[name];
-      delete this.originalMethods[name];
-    }
-  },
-});
-
-// This method is no longer needed
-// But still here for backwards compatibility
-// of helper chaining
-function protoWrap(proto, name, callback, isAsync) {
-  proto[name] = function(...args) {
-    if (isAsync) {
-      return callback.apply(this, args);
-    } else {
-      return this.then(function() {
-        return callback.apply(this, args);
-      });
-    }
-  };
-}
-
-function helper(app, name) {
-  let fn = helpers[name].method;
-  let meta = helpers[name].meta;
-  if (!meta.wait) {
-    return (...args) => fn.apply(app, [app, ...args]);
-  }
-
-  return (...args) => {
-    let lastPromise = run(() => resolve(getLastPromise()));
-
-    // wait for last helper's promise to resolve and then
-    // execute. To be safe, we need to tell the adapter we're going
-    // asynchronous here, because fn may not be invoked before we
-    // return.
-    asyncStart();
-    return lastPromise.then(() => fn.apply(app, [app, ...args])).finally(asyncEnd);
-  };
-}