discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@ember/canary-features/index.js

@@ -1,76 +0,0 @@
-import { assign } from '@ember/polyfills';
-import { ENV } from 'ember-environment';
-/**
- @module ember/canary-features
- @private
-*/
-export const DEFAULT_FEATURES = {
-    EMBER_LIBRARIES_ISREGISTERED: false,
-    EMBER_IMPROVED_INSTRUMENTATION: false,
-    EMBER_GLIMMER_NAMED_ARGUMENTS: true,
-    EMBER_ROUTING_ROUTER_SERVICE: true,
-    EMBER_ENGINES_MOUNT_PARAMS: true,
-    EMBER_MODULE_UNIFICATION: false,
-    GLIMMER_CUSTOM_COMPONENT_MANAGER: true,
-    EMBER_TEMPLATE_BLOCK_LET_HELPER: true,
-    EMBER_METAL_TRACKED_PROPERTIES: false,
-    EMBER_GLIMMER_ANGLE_BRACKET_INVOCATION: true,
-};
-/**
-  The hash of enabled Canary features. Add to this, any canary features
-  before creating your application.
-
-  Alternatively (and recommended), you can also define `EmberENV.FEATURES`
-  if you need to enable features flagged at runtime.
-
-  @class FEATURES
-  @namespace Ember
-  @static
-  @since 1.1.0
-  @public
-*/
-export const FEATURES = assign(DEFAULT_FEATURES, ENV.FEATURES);
-/**
-  Determine whether the specified `feature` is enabled. Used by Ember's
-  build tools to exclude experimental features from beta/stable builds.
-
-  You can define the following configuration options:
-
-  * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
-    enabled/disabled.
-
-  @method isEnabled
-  @param {String} feature The feature to check
-  @return {Boolean}
-  @for Ember.FEATURES
-  @since 1.1.0
-  @public
-*/
-export function isEnabled(feature) {
-    let featureValue = FEATURES[feature];
-    if (featureValue === true || featureValue === false) {
-        return featureValue;
-    }
-    else if (ENV.ENABLE_OPTIONAL_FEATURES) {
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-function featureValue(value) {
-    if (ENV.ENABLE_OPTIONAL_FEATURES && value === null) {
-        return true;
-    }
-    return value;
-}
-export const EMBER_LIBRARIES_ISREGISTERED = featureValue(FEATURES.EMBER_LIBRARIES_ISREGISTERED);
-export const EMBER_IMPROVED_INSTRUMENTATION = featureValue(FEATURES.EMBER_IMPROVED_INSTRUMENTATION);
-export const EMBER_GLIMMER_NAMED_ARGUMENTS = featureValue(FEATURES.EMBER_GLIMMER_NAMED_ARGUMENTS);
-export const EMBER_ROUTING_ROUTER_SERVICE = featureValue(FEATURES.EMBER_ROUTING_ROUTER_SERVICE);
-export const EMBER_ENGINES_MOUNT_PARAMS = featureValue(FEATURES.EMBER_ENGINES_MOUNT_PARAMS);
-export const EMBER_MODULE_UNIFICATION = featureValue(FEATURES.EMBER_MODULE_UNIFICATION);
-export const EMBER_METAL_TRACKED_PROPERTIES = featureValue(FEATURES.EMBER_METAL_TRACKED_PROPERTIES);
-export const GLIMMER_CUSTOM_COMPONENT_MANAGER = featureValue(FEATURES.GLIMMER_CUSTOM_COMPONENT_MANAGER);
-export const EMBER_TEMPLATE_BLOCK_LET_HELPER = featureValue(FEATURES.EMBER_TEMPLATE_BLOCK_LET_HELPER);
-export const EMBER_GLIMMER_ANGLE_BRACKET_INVOCATION = featureValue(FEATURES.EMBER_GLIMMER_ANGLE_BRACKET_INVOCATION);

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

@@ -1,50 +0,0 @@
-import { Object as EmberObject } from 'ember-runtime';
-import ControllerMixin from './lib/controller_mixin';
-import { InjectedProperty } from 'ember-metal';
-
-/**
-@module @ember/controller
-*/
-
-/**
-  @class Controller
-  @extends EmberObject
-  @uses Ember.ControllerMixin
-  @public
-*/
-const Controller = EmberObject.extend(ControllerMixin);
-
-/**
-  Creates a property that lazily looks up another controller in the container.
-  Can only be used when defining another controller.
-
-  Example:
-
-  ```app/controllers/post.js
-  import Controller, {
-    inject as controller
-  } from '@ember/controller';
-
-  export default Controller.extend({
-    posts: controller()
-  });
-  ```
-
-  This example will create a `posts` property on the `post` controller that
-  looks up the `posts` controller in the container, making it easy to
-  reference other controllers.
-
-  @method inject
-  @static
-  @for @ember/controller
-  @since 1.10.0
-  @param {String} name (optional) name of the controller to inject, defaults
-         to the property's name
-  @return {Ember.InjectedProperty} injection descriptor instance
-  @public
-*/
-export function inject(name, options) {
-  return new InjectedProperty('controller', name, options);
-}
-
-export default Controller;

data/dist/es/@ember/controller/lib/controller_mixin.js

@@ -1,42 +0,0 @@
-import { Mixin } from 'ember-metal';
-import { ActionHandler } from 'ember-runtime';
-
-/**
-  @class ControllerMixin
-  @namespace Ember
-  @uses Ember.ActionHandler
-  @private
-*/
-export default Mixin.create(ActionHandler, {
-  /* ducktype as a controller */
-  isController: true,
-
-  /**
-    The object to which actions from the view should be sent.
-
-    For example, when a Handlebars template uses the `{{action}}` helper,
-    it will attempt to send the action to the view's controller's `target`.
-
-    By default, the value of the target property is set to the router, and
-    is injected when a controller is instantiated. This injection is applied
-    as part of the application's initialization process. In most cases the
-    `target` property will automatically be set to the logical consumer of
-    actions for the controller.
-
-    @property target
-    @default null
-    @public
-  */
-  target: null,
-
-  store: null,
-
-  /**
-    The controller's current model. When retrieving or modifying a controller's
-    model, this property should be used instead of the `content` property.
-
-    @property model
-    @public
-  */
-  model: null,
-});

data/dist/es/@ember/controller/tests/controller_test.js

@@ -1,209 +0,0 @@
-import Controller, { inject as injectController } from '@ember/controller';
-import Service, { inject as injectService } from '@ember/service';
-import { Object as EmberObject } from 'ember-runtime';
-import { Mixin, get } from 'ember-metal';
-import { runDestroy, buildOwner } from 'internal-test-helpers';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Controller event handling',
-  class extends AbstractTestCase {
-    ['@test Action can be handled by a function on actions object'](assert) {
-      assert.expect(1);
-      let TestController = Controller.extend({
-        actions: {
-          poke() {
-            assert.ok(true, 'poked');
-          },
-        },
-      });
-      let controller = TestController.create();
-      controller.send('poke');
-    }
-
-    ['@test A handled action can be bubbled to the target for continued processing'](assert) {
-      assert.expect(2);
-      let TestController = Controller.extend({
-        actions: {
-          poke() {
-            assert.ok(true, 'poked 1');
-            return true;
-          },
-        },
-      });
-
-      let controller = TestController.create({
-        target: Controller.extend({
-          actions: {
-            poke() {
-              assert.ok(true, 'poked 2');
-            },
-          },
-        }).create(),
-      });
-      controller.send('poke');
-    }
-
-    ["@test Action can be handled by a superclass' actions object"](assert) {
-      assert.expect(4);
-
-      let SuperController = Controller.extend({
-        actions: {
-          foo() {
-            assert.ok(true, 'foo');
-          },
-          bar(msg) {
-            assert.equal(msg, 'HELLO');
-          },
-        },
-      });
-
-      let BarControllerMixin = Mixin.create({
-        actions: {
-          bar(msg) {
-            assert.equal(msg, 'HELLO');
-            this._super(msg);
-          },
-        },
-      });
-
-      let IndexController = SuperController.extend(BarControllerMixin, {
-        actions: {
-          baz() {
-            assert.ok(true, 'baz');
-          },
-        },
-      });
-
-      let controller = IndexController.create({});
-      controller.send('foo');
-      controller.send('bar', 'HELLO');
-      controller.send('baz');
-    }
-
-    ['@test .send asserts if called on a destroyed controller']() {
-      let owner = buildOwner();
-
-      owner.register(
-        'controller:application',
-        Controller.extend({
-          toString() {
-            return 'controller:rip-alley';
-          },
-        })
-      );
-
-      let controller = owner.lookup('controller:application');
-      runDestroy(owner);
-
-      expectAssertion(() => {
-        controller.send('trigger-me-dead');
-      }, "Attempted to call .send() with the action 'trigger-me-dead' on the destroyed object 'controller:rip-alley'.");
-    }
-  }
-);
-
-moduleFor(
-  'Controller deprecations -> Controller Content -> Model Alias',
-  class extends AbstractTestCase {
-    ['@test `content` is not moved to `model` when `model` is unset'](assert) {
-      assert.expect(2);
-      let controller;
-
-      ignoreDeprecation(function() {
-        controller = Controller.extend({
-          content: 'foo-bar',
-        }).create();
-      });
-
-      assert.notEqual(controller.get('model'), 'foo-bar', 'model is set properly');
-      assert.equal(controller.get('content'), 'foo-bar', 'content is not set properly');
-    }
-
-    ['@test specifying `content` (without `model` specified) does not result in deprecation'](
-      assert
-    ) {
-      assert.expect(2);
-      expectNoDeprecation();
-
-      let controller = Controller.extend({
-        content: 'foo-bar',
-      }).create();
-
-      assert.equal(get(controller, 'content'), 'foo-bar');
-    }
-
-    ['@test specifying `content` (with `model` specified) does not result in deprecation'](assert) {
-      assert.expect(3);
-      expectNoDeprecation();
-
-      let controller = Controller.extend({
-        content: 'foo-bar',
-        model: 'blammo',
-      }).create();
-
-      assert.equal(get(controller, 'content'), 'foo-bar');
-      assert.equal(get(controller, 'model'), 'blammo');
-    }
-  }
-);
-
-moduleFor(
-  'Controller deprecations -> Controller injected properties',
-  class extends AbstractTestCase {
-    ['@test defining a controller on a non-controller should fail assertion']() {
-      expectAssertion(function() {
-        let owner = buildOwner();
-
-        let AnObject = EmberObject.extend({
-          foo: injectController('bar'),
-        });
-
-        owner.register('controller:bar', EmberObject.extend());
-        owner.register('foo:main', AnObject);
-
-        owner.lookup('foo:main');
-      }, /Defining `foo` as an injected controller property on a non-controller \(`foo:main`\) is not allowed/);
-    }
-
-    ['@test controllers can be injected into controllers'](assert) {
-      let owner = buildOwner();
-
-      owner.register(
-        'controller:post',
-        Controller.extend({
-          postsController: injectController('posts'),
-        })
-      );
-
-      owner.register('controller:posts', Controller.extend());
-
-      let postController = owner.lookup('controller:post');
-      let postsController = owner.lookup('controller:posts');
-
-      assert.equal(
-        postsController,
-        postController.get('postsController'),
-        'controller.posts is injected'
-      );
-    }
-
-    ['@test services can be injected into controllers'](assert) {
-      let owner = buildOwner();
-
-      owner.register(
-        'controller:application',
-        Controller.extend({
-          authService: injectService('auth'),
-        })
-      );
-
-      owner.register('service:auth', Service.extend());
-
-      let appController = owner.lookup('controller:application');
-      let authService = owner.lookup('service:auth');
-
-      assert.equal(authService, appController.get('authService'), 'service.auth is injected');
-    }
-  }
-);

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

@@ -1,264 +0,0 @@
-import EmberError from '@ember/error';
-import { DEBUG } from '@glimmer/env';
-import { isChrome, isFirefox } from 'ember-browser-environment';
-import _deprecate from './lib/deprecate';
-import { isTesting } from './lib/testing';
-import _warn from './lib/warn';
-export { registerHandler as registerWarnHandler } from './lib/warn';
-export { registerHandler as registerDeprecationHandler } from './lib/deprecate';
-export { isTesting, setTesting } from './lib/testing';
-// These are the default production build versions:
-const noop = () => { };
-let assert = noop;
-let info = noop;
-let warn = noop;
-let debug = noop;
-let deprecate = noop;
-let debugSeal = noop;
-let debugFreeze = noop;
-let runInDebug = noop;
-let setDebugFunction = noop;
-let getDebugFunction = noop;
-let deprecateFunc = function () {
-    return arguments[arguments.length - 1];
-};
-if (DEBUG) {
-    setDebugFunction = function (type, callback) {
-        switch (type) {
-            case 'assert':
-                return (assert = callback);
-            case 'info':
-                return (info = callback);
-            case 'warn':
-                return (warn = callback);
-            case 'debug':
-                return (debug = callback);
-            case 'deprecate':
-                return (deprecate = callback);
-            case 'debugSeal':
-                return (debugSeal = callback);
-            case 'debugFreeze':
-                return (debugFreeze = callback);
-            case 'runInDebug':
-                return (runInDebug = callback);
-            case 'deprecateFunc':
-                return (deprecateFunc = callback);
-        }
-    };
-    getDebugFunction = function (type) {
-        switch (type) {
-            case 'assert':
-                return assert;
-            case 'info':
-                return info;
-            case 'warn':
-                return warn;
-            case 'debug':
-                return debug;
-            case 'deprecate':
-                return deprecate;
-            case 'debugSeal':
-                return debugSeal;
-            case 'debugFreeze':
-                return debugFreeze;
-            case 'runInDebug':
-                return runInDebug;
-            case 'deprecateFunc':
-                return deprecateFunc;
-        }
-    };
-}
-/**
-@module @ember/debug
-*/
-if (DEBUG) {
-    /**
-      Verify that a certain expectation is met, or throw a exception otherwise.
-  
-      This is useful for communicating assumptions in the code to other human
-      readers as well as catching bugs that accidentally violates these
-      expectations.
-  
-      Assertions are removed from production builds, so they can be freely added
-      for documentation and debugging purposes without worries of incuring any
-      performance penalty. However, because of that, they should not be used for
-      checks that could reasonably fail during normal usage. Furthermore, care
-      should be taken to avoid accidentally relying on side-effects produced from
-      evaluating the condition itself, since the code will not run in production.
-  
-      ```javascript
-      import { assert } from '@ember/debug';
-  
-      // Test for truthiness
-      assert('Must pass a string', typeof str === 'string');
-  
-      // Fail unconditionally
-      assert('This code path should never be run');
-      ```
-  
-      @method assert
-      @static
-      @for @ember/debug
-      @param {String} description Describes the expectation. This will become the
-        text of the Error thrown if the assertion fails.
-      @param {Boolean} condition Must be truthy for the assertion to pass. If
-        falsy, an exception will be thrown.
-      @public
-      @since 1.0.0
-    */
-    setDebugFunction('assert', function assert(desc, test) {
-        if (!test) {
-            throw new EmberError(`Assertion Failed: ${desc}`);
-        }
-    });
-    /**
-      Display a debug notice.
-  
-      Calls to this function are removed from production builds, so they can be
-      freely added for documentation and debugging purposes without worries of
-      incuring any performance penalty.
-  
-      ```javascript
-      import { debug } from '@ember/debug';
-  
-      debug('I\'m a debug notice!');
-      ```
-  
-      @method debug
-      @for @ember/debug
-      @static
-      @param {String} message A debug message to display.
-      @public
-    */
-    setDebugFunction('debug', function debug(message) {
-        /* eslint-disable no-console */
-        if (console.debug) {
-            console.debug(`DEBUG: ${message}`);
-        }
-        else {
-            console.log(`DEBUG: ${message}`);
-        }
-        /* eslint-ensable no-console */
-    });
-    /**
-      Display an info notice.
-  
-      Calls to this function are removed from production builds, so they can be
-      freely added for documentation and debugging purposes without worries of
-      incuring any performance penalty.
-  
-      @method info
-      @private
-    */
-    setDebugFunction('info', function info() {
-        console.info(...arguments); /* eslint-disable-line no-console */
-    });
-    /**
-     @module @ember/application
-     @public
-    */
-    /**
-      Alias an old, deprecated method with its new counterpart.
-  
-      Display a deprecation warning with the provided message and a stack trace
-      (Chrome and Firefox only) when the assigned method is called.
-  
-      Calls to this function are removed from production builds, so they can be
-      freely added for documentation and debugging purposes without worries of
-      incuring any performance penalty.
-  
-      ```javascript
-      import { deprecateFunc } from '@ember/application/deprecations';
-  
-      Ember.oldMethod = deprecateFunc('Please use the new, updated method', options, Ember.newMethod);
-      ```
-  
-      @method deprecateFunc
-      @static
-      @for @ember/application/deprecations
-      @param {String} message A description of the deprecation.
-      @param {Object} [options] The options object for `deprecate`.
-      @param {Function} func The new function called to replace its deprecated counterpart.
-      @return {Function} A new function that wraps the original function with a deprecation warning
-      @private
-    */
-    setDebugFunction('deprecateFunc', function deprecateFunc(...args) {
-        if (args.length === 3) {
-            let [message, options, func] = args;
-            return function () {
-                deprecate(message, false, options);
-                return func.apply(this, arguments);
-            };
-        }
-        else {
-            let [message, func] = args;
-            return function () {
-                deprecate(message);
-                return func.apply(this, arguments);
-            };
-        }
-    });
-    /**
-     @module @ember/debug
-     @public
-    */
-    /**
-      Run a function meant for debugging.
-  
-      Calls to this function are removed from production builds, so they can be
-      freely added for documentation and debugging purposes without worries of
-      incuring any performance penalty.
-  
-      ```javascript
-      import Component from '@ember/component';
-      import { runInDebug } from '@ember/debug';
-  
-      runInDebug(() => {
-        Component.reopen({
-          didInsertElement() {
-            console.log("I'm happy");
-          }
-        });
-      });
-      ```
-  
-      @method runInDebug
-      @for @ember/debug
-      @static
-      @param {Function} func The function to be executed.
-      @since 1.5.0
-      @public
-    */
-    setDebugFunction('runInDebug', function runInDebug(func) {
-        func();
-    });
-    setDebugFunction('debugSeal', function debugSeal(obj) {
-        Object.seal(obj);
-    });
-    setDebugFunction('debugFreeze', function debugFreeze(obj) {
-        Object.freeze(obj);
-    });
-    setDebugFunction('deprecate', _deprecate);
-    setDebugFunction('warn', _warn);
-}
-let _warnIfUsingStrippedFeatureFlags;
-if (DEBUG && !isTesting()) {
-    if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
-        window.addEventListener('load', () => {
-            if (document.documentElement &&
-                document.documentElement.dataset &&
-                !document.documentElement.dataset.emberExtension) {
-                let downloadURL;
-                if (isChrome) {
-                    downloadURL =
-                        'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
-                }
-                else if (isFirefox) {
-                    downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/';
-                }
-                debug(`For more advanced debugging, install the Ember Inspector from ${downloadURL}`);
-            }
-        }, false);
-    }
-}
-export { assert, info, warn, debug, deprecate, debugSeal, debugFreeze, runInDebug, deprecateFunc, setDebugFunction, getDebugFunction, _warnIfUsingStrippedFeatureFlags, };