discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@ember/debug/lib/deprecate.js

@@ -1,198 +0,0 @@
-import { DEPRECATE_ID_MISSING, DEPRECATE_OPTIONS_MISSING, DEPRECATE_UNTIL_MISSING, } from '@ember/deprecated-features';
-import { DEBUG } from '@glimmer/env';
-import { ENV } from 'ember-environment';
-import { assert } from '../index';
-import { invoke, registerHandler as genericRegisterHandler } from './handlers';
-/**
- @module @ember/debug
- @public
-*/
-/**
-  Allows for runtime registration of handler functions that override the default deprecation behavior.
-  Deprecations are invoked by calls to [@ember/application/deprecations/deprecate](https://emberjs.com/api/ember/release/classes/@ember%2Fapplication%2Fdeprecations/methods/deprecate?anchor=deprecate).
-  The following example demonstrates its usage by registering a handler that throws an error if the
-  message contains the word "should", otherwise defers to the default handler.
-
-  ```javascript
-  import { registerDeprecationHandler } from '@ember/debug';
-
-  registerDeprecationHandler((message, options, next) => {
-    if (message.indexOf('should') !== -1) {
-      throw new Error(`Deprecation message with should: ${message}`);
-    } else {
-      // defer to whatever handler was registered before this one
-      next(message, options);
-    }
-  });
-  ```
-
-  The handler function takes the following arguments:
-
-  <ul>
-    <li> <code>message</code> - The message received from the deprecation call.</li>
-    <li> <code>options</code> - An object passed in with the deprecation call containing additional information including:</li>
-      <ul>
-        <li> <code>id</code> - An id of the deprecation in the form of <code>package-name.specific-deprecation</code>.</li>
-        <li> <code>until</code> - The Ember version number the feature and deprecation will be removed in.</li>
-      </ul>
-    <li> <code>next</code> - A function that calls into the previously registered handler.</li>
-  </ul>
-
-  @public
-  @static
-  @method registerDeprecationHandler
-  @for @ember/debug
-  @param handler {Function} A function to handle deprecation calls.
-  @since 2.1.0
-*/
-let registerHandler = () => { };
-let missingOptionsDeprecation;
-let missingOptionsIdDeprecation;
-let missingOptionsUntilDeprecation;
-let deprecate = () => { };
-if (DEBUG) {
-    registerHandler = function registerHandler(handler) {
-        genericRegisterHandler('deprecate', handler);
-    };
-    let formatMessage = function formatMessage(_message, options) {
-        let message = _message;
-        if (options && options.id) {
-            message = message + ` [deprecation id: ${options.id}]`;
-        }
-        if (options && options.url) {
-            message += ` See ${options.url} for more details.`;
-        }
-        return message;
-    };
-    registerHandler(function logDeprecationToConsole(message, options) {
-        let updatedMessage = formatMessage(message, options);
-        console.warn(`DEPRECATION: ${updatedMessage}`); // eslint-disable-line no-console
-    });
-    let captureErrorForStack;
-    if (new Error().stack) {
-        captureErrorForStack = () => new Error();
-    }
-    else {
-        captureErrorForStack = () => {
-            try {
-                __fail__.fail();
-            }
-            catch (e) {
-                return e;
-            }
-        };
-    }
-    registerHandler(function logDeprecationStackTrace(message, options, next) {
-        if (ENV.LOG_STACKTRACE_ON_DEPRECATION) {
-            let stackStr = '';
-            let error = captureErrorForStack();
-            let stack;
-            if (error.stack) {
-                if (error['arguments']) {
-                    // Chrome
-                    stack = error.stack
-                        .replace(/^\s+at\s+/gm, '')
-                        .replace(/^([^\(]+?)([\n$])/gm, '{anonymous}($1)$2')
-                        .replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, '{anonymous}($1)')
-                        .split('\n');
-                    stack.shift();
-                }
-                else {
-                    // Firefox
-                    stack = error.stack
-                        .replace(/(?:\n@:0)?\s+$/m, '')
-                        .replace(/^\(/gm, '{anonymous}(')
-                        .split('\n');
-                }
-                stackStr = `\n    ${stack.slice(2).join('\n    ')}`;
-            }
-            let updatedMessage = formatMessage(message, options);
-            console.warn(`DEPRECATION: ${updatedMessage}${stackStr}`); // eslint-disable-line no-console
-        }
-        else {
-            next(message, options);
-        }
-    });
-    registerHandler(function raiseOnDeprecation(message, options, next) {
-        if (ENV.RAISE_ON_DEPRECATION) {
-            let updatedMessage = formatMessage(message);
-            throw new Error(updatedMessage);
-        }
-        else {
-            next(message, options);
-        }
-    });
-    missingOptionsDeprecation =
-        'When calling `deprecate` you ' +
-            'must provide an `options` hash as the third parameter.  ' +
-            '`options` should include `id` and `until` properties.';
-    missingOptionsIdDeprecation = 'When calling `deprecate` you must provide `id` in options.';
-    missingOptionsUntilDeprecation = 'When calling `deprecate` you must provide `until` in options.';
-    /**
-     @module @ember/application
-     @public
-     */
-    /**
-      Display a deprecation warning with the provided message and a stack trace
-      (Chrome and Firefox only).
-  
-      * In a production build, this method is defined as an empty function (NOP).
-      Uses of this method in Ember itself are stripped from the ember.prod.js build.
-  
-      @method deprecate
-      @for @ember/application/deprecations
-      @param {String} message A description of the deprecation.
-      @param {Boolean} test A boolean. If falsy, the deprecation will be displayed.
-      @param {Object} options
-      @param {String} options.id A unique id for this deprecation. The id can be
-        used by Ember debugging tools to change the behavior (raise, log or silence)
-        for that specific deprecation. The id should be namespaced by dots, e.g.
-        "view.helper.select".
-      @param {string} options.until The version of Ember when this deprecation
-        warning will be removed.
-      @param {String} [options.url] An optional url to the transition guide on the
-        emberjs.com website.
-      @static
-      @public
-      @since 1.0.0
-    */
-    deprecate = function deprecate(message, test, options) {
-        if (ENV._ENABLE_DEPRECATION_OPTIONS_SUPPORT !== true) {
-            assert(missingOptionsDeprecation, !!(options && (options.id || options.until)));
-            assert(missingOptionsIdDeprecation, !!options.id);
-            assert(missingOptionsUntilDeprecation, !!options.until);
-        }
-        if (DEPRECATE_OPTIONS_MISSING &&
-            (!options || (!options.id && !options.until)) &&
-            ENV._ENABLE_DEPRECATION_OPTIONS_SUPPORT === true) {
-            deprecate(missingOptionsDeprecation, false, {
-                id: 'ember-debug.deprecate-options-missing',
-                until: '3.0.0',
-                url: 'https://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options',
-            });
-        }
-        if (DEPRECATE_ID_MISSING &&
-            options &&
-            !options.id &&
-            ENV._ENABLE_DEPRECATION_OPTIONS_SUPPORT === true) {
-            deprecate(missingOptionsIdDeprecation, false, {
-                id: 'ember-debug.deprecate-id-missing',
-                until: '3.0.0',
-                url: 'https://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options',
-            });
-        }
-        if (DEPRECATE_UNTIL_MISSING &&
-            options &&
-            !options.until &&
-            ENV._ENABLE_DEPRECATION_OPTIONS_SUPPORT === true) {
-            deprecate(missingOptionsUntilDeprecation, !!(options && options.until), {
-                id: 'ember-debug.deprecate-until-missing',
-                until: '3.0.0',
-                url: 'https://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options',
-            });
-        }
-        invoke('deprecate', message, test, options);
-    };
-}
-export default deprecate;
-export { registerHandler, missingOptionsDeprecation, missingOptionsIdDeprecation, missingOptionsUntilDeprecation, };

data/dist/es/@ember/debug/lib/handlers.js

@@ -1,22 +0,0 @@
-import { DEBUG } from '@glimmer/env';
-export let HANDLERS = {};
-let registerHandler = () => { };
-let invoke = () => { };
-if (DEBUG) {
-    registerHandler = function registerHandler(type, callback) {
-        let nextHandler = HANDLERS[type] || (() => { });
-        HANDLERS[type] = (message, options) => {
-            callback(message, options, nextHandler);
-        };
-    };
-    invoke = function invoke(type, message, test, options) {
-        if (test) {
-            return;
-        }
-        let handlerForType = HANDLERS[type];
-        if (handlerForType) {
-            handlerForType(message, options);
-        }
-    };
-}
-export { registerHandler, invoke };

data/dist/es/@ember/debug/lib/testing.js

@@ -1,7 +0,0 @@
-let testing = false;
-export function isTesting() {
-    return testing;
-}
-export function setTesting(value) {
-    testing = !!value;
-}

data/dist/es/@ember/debug/lib/warn.js

@@ -1,107 +0,0 @@
-import { DEBUG } from '@glimmer/env';
-import { ENV } from 'ember-environment';
-import { assert } from '../index';
-import deprecate from './deprecate';
-import { invoke, registerHandler as genericRegisterHandler } from './handlers';
-let registerHandler = () => { };
-let warn = () => { };
-let missingOptionsDeprecation;
-let missingOptionsIdDeprecation;
-/**
-@module @ember/debug
-*/
-if (DEBUG) {
-    /**
-      Allows for runtime registration of handler functions that override the default warning behavior.
-      Warnings are invoked by calls made to [@ember/debug/warn](https://emberjs.com/api/ember/release/classes/@ember%2Fdebug/methods/warn?anchor=warn).
-      The following example demonstrates its usage by registering a handler that does nothing overriding Ember's
-      default warning behavior.
-  
-      ```javascript
-      import { registerWarnHandler } from '@ember/debug';
-  
-      // next is not called, so no warnings get the default behavior
-      registerWarnHandler(() => {});
-      ```
-  
-      The handler function takes the following arguments:
-  
-      <ul>
-        <li> <code>message</code> - The message received from the warn call. </li>
-        <li> <code>options</code> - An object passed in with the warn call containing additional information including:</li>
-          <ul>
-            <li> <code>id</code> - An id of the warning in the form of <code>package-name.specific-warning</code>.</li>
-          </ul>
-        <li> <code>next</code> - A function that calls into the previously registered handler.</li>
-      </ul>
-  
-      @public
-      @static
-      @method registerWarnHandler
-      @for @ember/debug
-      @param handler {Function} A function to handle warnings.
-      @since 2.1.0
-    */
-    registerHandler = function registerHandler(handler) {
-        genericRegisterHandler('warn', handler);
-    };
-    registerHandler(function logWarning(message) {
-        /* eslint-disable no-console */
-        console.warn(`WARNING: ${message}`);
-        if (console.trace) {
-            console.trace();
-        }
-        /* eslint-enable no-console */
-    });
-    missingOptionsDeprecation =
-        'When calling `warn` you ' +
-            'must provide an `options` hash as the third parameter.  ' +
-            '`options` should include an `id` property.';
-    missingOptionsIdDeprecation = 'When calling `warn` you must provide `id` in options.';
-    /**
-      Display a warning with the provided message.
-  
-      * In a production build, this method is defined as an empty function (NOP).
-      Uses of this method in Ember itself are stripped from the ember.prod.js build.
-  
-      @method warn
-      @for @ember/debug
-      @static
-      @param {String} message A warning to display.
-      @param {Boolean} test An optional boolean. If falsy, the warning
-        will be displayed.
-      @param {Object} options An object that can be used to pass a unique
-        `id` for this warning.  The `id` can be used by Ember debugging tools
-        to change the behavior (raise, log, or silence) for that specific warning.
-        The `id` should be namespaced by dots, e.g. "ember-debug.feature-flag-with-features-stripped"
-      @public
-      @since 1.0.0
-    */
-    warn = function warn(message, test, options) {
-        if (arguments.length === 2 && typeof test === 'object') {
-            options = test;
-            test = false;
-        }
-        if (ENV._ENABLE_WARN_OPTIONS_SUPPORT !== true) {
-            assert(missingOptionsDeprecation, !!options);
-            assert(missingOptionsIdDeprecation, !!(options && options.id));
-        }
-        if (!options && ENV._ENABLE_WARN_OPTIONS_SUPPORT === true) {
-            deprecate(missingOptionsDeprecation, false, {
-                id: 'ember-debug.warn-options-missing',
-                until: '3.0.0',
-                url: 'https://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options',
-            });
-        }
-        if (options && !options.id && ENV._ENABLE_WARN_OPTIONS_SUPPORT === true) {
-            deprecate(missingOptionsIdDeprecation, false, {
-                id: 'ember-debug.warn-id-missing',
-                until: '3.0.0',
-                url: 'https://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options',
-            });
-        }
-        invoke('warn', message, test, options);
-    };
-}
-export default warn;
-export { registerHandler, missingOptionsIdDeprecation, missingOptionsDeprecation };

data/dist/es/@ember/debug/tests/handlers-test.js

@@ -1,144 +0,0 @@
-import { HANDLERS, registerHandler, invoke } from '../lib/handlers';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'ember-debug: registerHandler',
-  class extends TestCase {
-    teardown() {
-      delete HANDLERS.blarz;
-    }
-
-    ['@test calls handler on `invoke` when `falsey`'](assert) {
-      assert.expect(2);
-
-      function handler(message) {
-        assert.ok(true, 'called handler');
-        assert.equal(message, 'Foo bar');
-      }
-
-      registerHandler('blarz', handler);
-
-      invoke('blarz', 'Foo bar', false);
-    }
-
-    ['@test does not call handler on `invoke` when `truthy`'](assert) {
-      assert.expect(0);
-
-      function handler() {
-        assert.ok(false, 'called handler');
-      }
-
-      registerHandler('blarz', handler);
-
-      invoke('blarz', 'Foo bar', true);
-    }
-
-    ['@test calling `invoke` without handlers does not throw an error'](assert) {
-      assert.expect(0);
-
-      invoke('blarz', 'Foo bar', false);
-    }
-
-    ['@test invoking `next` argument calls the next handler'](assert) {
-      assert.expect(2);
-
-      function handler1() {
-        assert.ok(true, 'called handler1');
-      }
-
-      function handler2(message, options, next) {
-        assert.ok(true, 'called handler2');
-        next(message, options);
-      }
-
-      registerHandler('blarz', handler1);
-      registerHandler('blarz', handler2);
-
-      invoke('blarz', 'Foo', false);
-    }
-
-    ['@test invoking `next` when no other handlers exists does not error'](assert) {
-      assert.expect(1);
-
-      function handler(message, options, next) {
-        assert.ok(true, 'called handler1');
-
-        next(message, options);
-      }
-
-      registerHandler('blarz', handler);
-
-      invoke('blarz', 'Foo', false);
-    }
-
-    ['@test handlers are called in the proper order'](assert) {
-      assert.expect(11);
-
-      let expectedMessage = 'This is the message';
-      let expectedOptions = { id: 'foo-bar' };
-      let expected = ['first', 'second', 'third', 'fourth', 'fifth'];
-      let actualCalls = [];
-
-      function generateHandler(item) {
-        return function(message, options, next) {
-          assert.equal(message, expectedMessage, `message supplied to ${item} handler is correct`);
-          assert.equal(options, expectedOptions, `options supplied to ${item} handler is correct`);
-
-          actualCalls.push(item);
-
-          next(message, options);
-        };
-      }
-
-      expected.forEach(item => registerHandler('blarz', generateHandler(item)));
-
-      invoke('blarz', expectedMessage, false, expectedOptions);
-
-      assert.deepEqual(actualCalls, expected.reverse(), 'handlers were called in proper order');
-    }
-
-    ['@test not invoking `next` prevents further handlers from being called'](assert) {
-      assert.expect(1);
-
-      function handler1() {
-        assert.ok(false, 'called handler1');
-      }
-
-      function handler2() {
-        assert.ok(true, 'called handler2');
-      }
-
-      registerHandler('blarz', handler1);
-      registerHandler('blarz', handler2);
-
-      invoke('blarz', 'Foo', false);
-    }
-
-    ['@test handlers can call `next` with custom message and/or options'](assert) {
-      assert.expect(4);
-
-      let initialMessage = 'initial message';
-      let initialOptions = { id: 'initial-options' };
-
-      let handler2Message = 'Handler2 Message';
-      let handler2Options = { id: 'handler-2' };
-
-      function handler1(message, options) {
-        assert.equal(message, handler2Message, 'handler2 message provided to handler1');
-        assert.equal(options, handler2Options, 'handler2 options provided to handler1');
-      }
-
-      function handler2(message, options, next) {
-        assert.equal(message, initialMessage, 'initial message provided to handler2');
-        assert.equal(options, initialOptions, 'initial options proivided to handler2');
-
-        next(handler2Message, handler2Options);
-      }
-
-      registerHandler('blarz', handler1);
-      registerHandler('blarz', handler2);
-
-      invoke('blarz', initialMessage, false, initialOptions);
-    }
-  }
-);