ember-source 6.12.0 → 7.0.0-alpha.1

package/dist/prod/packages/dag-map/index.js

@@ -0,0 +1,202 @@
+/**
+ * A topologically ordered map of key/value pairs with a simple API for adding constraints.
+ *
+ * Edges can forward reference keys that have not been added yet (the forward reference will
+ * map the key to undefined).
+ */
+var DAG = function () {
+  function DAG() {
+    this._vertices = new Vertices();
+  }
+  /**
+   * Adds a key/value pair with dependencies on other key/value pairs.
+   *
+   * @public
+   * @param key    The key of the vertex to be added.
+   * @param value  The value of that vertex.
+   * @param before A key or array of keys of the vertices that must
+   *               be visited before this vertex.
+   * @param after  An string or array of strings with the keys of the
+   *               vertices that must be after this vertex is visited.
+   */
+  DAG.prototype.add = function (key, value, before, after) {
+    if (!key) throw new Error('argument `key` is required');
+    var vertices = this._vertices;
+    var v = vertices.add(key);
+    v.val = value;
+    if (before) {
+      if (typeof before === "string") {
+        vertices.addEdge(v, vertices.add(before));
+      } else {
+        for (var i = 0; i < before.length; i++) {
+          vertices.addEdge(v, vertices.add(before[i]));
+        }
+      }
+    }
+    if (after) {
+      if (typeof after === "string") {
+        vertices.addEdge(vertices.add(after), v);
+      } else {
+        for (var i = 0; i < after.length; i++) {
+          vertices.addEdge(vertices.add(after[i]), v);
+        }
+      }
+    }
+  };
+  /**
+   * @deprecated please use add.
+   */
+  DAG.prototype.addEdges = function (key, value, before, after) {
+    this.add(key, value, before, after);
+  };
+  /**
+   * Visits key/value pairs in topological order.
+   *
+   * @public
+   * @param callback The function to be invoked with each key/value.
+   */
+  DAG.prototype.each = function (callback) {
+    this._vertices.walk(callback);
+  };
+  /**
+   * @deprecated please use each.
+   */
+  DAG.prototype.topsort = function (callback) {
+    this.each(callback);
+  };
+  return DAG;
+}();
+/** @private */
+var Vertices = function () {
+  function Vertices() {
+    this.length = 0;
+    this.stack = new IntStack();
+    this.path = new IntStack();
+    this.result = new IntStack();
+  }
+  Vertices.prototype.add = function (key) {
+    if (!key) throw new Error("missing key");
+    var l = this.length | 0;
+    var vertex;
+    for (var i = 0; i < l; i++) {
+      vertex = this[i];
+      if (vertex.key === key) return vertex;
+    }
+    this.length = l + 1;
+    return this[l] = {
+      idx: l,
+      key: key,
+      val: undefined,
+      out: false,
+      flag: false,
+      length: 0
+    };
+  };
+  Vertices.prototype.addEdge = function (v, w) {
+    this.check(v, w.key);
+    var l = w.length | 0;
+    for (var i = 0; i < l; i++) {
+      if (w[i] === v.idx) return;
+    }
+    w.length = l + 1;
+    w[l] = v.idx;
+    v.out = true;
+  };
+  Vertices.prototype.walk = function (cb) {
+    this.reset();
+    for (var i = 0; i < this.length; i++) {
+      var vertex = this[i];
+      if (vertex.out) continue;
+      this.visit(vertex, "");
+    }
+    this.each(this.result, cb);
+  };
+  Vertices.prototype.check = function (v, w) {
+    if (v.key === w) {
+      throw new Error("cycle detected: " + w + " <- " + w);
+    }
+    // quick check
+    if (v.length === 0) return;
+    // shallow check
+    for (var i = 0; i < v.length; i++) {
+      var key = this[v[i]].key;
+      if (key === w) {
+        throw new Error("cycle detected: " + w + " <- " + v.key + " <- " + w);
+      }
+    }
+    // deep check
+    this.reset();
+    this.visit(v, w);
+    if (this.path.length > 0) {
+      var msg_1 = "cycle detected: " + w;
+      this.each(this.path, function (key) {
+        msg_1 += " <- " + key;
+      });
+      throw new Error(msg_1);
+    }
+  };
+  Vertices.prototype.reset = function () {
+    this.stack.length = 0;
+    this.path.length = 0;
+    this.result.length = 0;
+    for (var i = 0, l = this.length; i < l; i++) {
+      this[i].flag = false;
+    }
+  };
+  Vertices.prototype.visit = function (start, search) {
+    var _a = this,
+      stack = _a.stack,
+      path = _a.path,
+      result = _a.result;
+    stack.push(start.idx);
+    while (stack.length) {
+      var index = stack.pop() | 0;
+      if (index >= 0) {
+        // enter
+        var vertex = this[index];
+        if (vertex.flag) continue;
+        vertex.flag = true;
+        path.push(index);
+        if (search === vertex.key) break;
+        // push exit
+        stack.push(~index);
+        this.pushIncoming(vertex);
+      } else {
+        // exit
+        path.pop();
+        result.push(~index);
+      }
+    }
+  };
+  Vertices.prototype.pushIncoming = function (incomming) {
+    var stack = this.stack;
+    for (var i = incomming.length - 1; i >= 0; i--) {
+      var index = incomming[i];
+      if (!this[index].flag) {
+        stack.push(index);
+      }
+    }
+  };
+  Vertices.prototype.each = function (indices, cb) {
+    for (var i = 0, l = indices.length; i < l; i++) {
+      var vertex = this[indices[i]];
+      cb(vertex.key, vertex.val);
+    }
+  };
+  return Vertices;
+}();
+/** @private */
+var IntStack = function () {
+  function IntStack() {
+    this.length = 0;
+  }
+  IntStack.prototype.push = function (n) {
+    this[this.length++] = n | 0;
+  };
+  IntStack.prototype.pop = function () {
+    return this[--this.length] | 0;
+  };
+  return IntStack;
+}();
+
+export { DAG as default };

package/dist/prod/packages/ember/version.js

@@ -0,0 +1,4 @@
+// this file gets replaced with the real value during the build
+const VERSION = '7.0.0-alpha.1';
+
+export { VERSION as default };

package/dist/prod/packages/ember-template-compiler/index.js

@@ -0,0 +1,100 @@
+import '../shared-chunks/fragment-EpVz5Xuc.js';
+import '../@glimmer/wire-format/index.js';
+import { p as precompile$1 } from '../shared-chunks/compiler-Ddfo5StE.js';
+export { a as _preprocess, b as _print } from '../shared-chunks/compiler-Ddfo5StE.js';
+import '../@ember/-internals/environment/index.js';
+import { STRICT_MODE_KEYWORDS, STRICT_MODE_TRANSFORMS, RESOLUTION_MODE_TRANSFORMS } from '../@ember/template-compiler/lib/plugins/index.js';
+import '../shared-chunks/super-Cm_a_cLQ.js';
+import { C as Cache } from '../shared-chunks/cache-qDyqAcpg.js';
+import '../shared-chunks/transform-resolutions-C7wq_Q_c.js';
+
+/*
+  This diverges from `Ember.String.dasherize` so that`<XFoo />` can resolve to `x-foo`.
+  `Ember.String.dasherize` would resolve it to `xfoo`..
+*/
+const SIMPLE_DASHERIZE_REGEXP = /[A-Z]|::/g;
+const ALPHA = /[A-Za-z0-9]/;
+const COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE = new Cache(1000, key => key.replace(SIMPLE_DASHERIZE_REGEXP, (char, index) => {
+  if (char === '::') {
+    return '/';
+  }
+  if (index === 0 || !ALPHA.test(key[index - 1])) {
+    return char.toLowerCase();
+  }
+  return `-${char.toLowerCase()}`;
+}));
+
+let USER_PLUGINS = [];
+function buildCompileOptions(_options) {
+  let moduleName = _options.moduleName;
+  let options = Object.assign({
+    meta: {},
+    isProduction: false,
+    plugins: {
+      ast: []
+    }
+  }, _options, {
+    moduleName,
+    customizeComponentName(tagname) {
+      return COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get(tagname);
+    }
+  });
+  if ('locals' in options && !options.locals) {
+    // Glimmer's precompile options declare `locals` like:
+    //    locals?: string[]
+    // but many in-use versions of babel-plugin-htmlbars-inline-precompile will
+    // set locals to `null`. This used to work but only because glimmer was
+    // ignoring locals for non-strict templates, and now it supports that case.
+    delete options.locals;
+  }
+
+  // move `moduleName` into `meta` property
+  if (options.moduleName) {
+    let meta = options.meta;
+    meta.moduleName = options.moduleName;
+  }
+  if (options.strictMode) {
+    options.keywords = STRICT_MODE_KEYWORDS;
+  }
+  return options;
+}
+function transformsFor(options) {
+  return options.strictMode ? STRICT_MODE_TRANSFORMS : RESOLUTION_MODE_TRANSFORMS;
+}
+function compileOptions(_options = {}) {
+  let options = buildCompileOptions(_options);
+  let builtInPlugins = transformsFor(options);
+  if (!_options.plugins) {
+    options.plugins = {
+      ast: [...USER_PLUGINS, ...builtInPlugins]
+    };
+  } else {
+    let potententialPugins = [...USER_PLUGINS, ...builtInPlugins];
+    let pluginsToAdd = potententialPugins.filter(plugin => {
+      return options.plugins.ast.indexOf(plugin) === -1;
+    });
+    options.plugins.ast = options.plugins.ast.concat(pluginsToAdd);
+  }
+  return options;
+}
+
+/**
+@module ember
+*/
+
+
+/**
+  Uses HTMLBars `compile` function to process a string into a compiled template string.
+  The returned string must be passed through `Ember.HTMLBars.template`.
+
+  This is not present in production builds.
+
+  @private
+  @method precompile
+  @param {String} templateString This is the string to be compiled by HTMLBars.
+*/
+function precompile(templateString, options = {}) {
+  return precompile$1(templateString, compileOptions(options));
+}
+
+export { buildCompileOptions as _buildCompileOptions, precompile };

package/dist/prod/packages/ember-testing/index.js

@@ -0,0 +1,6 @@
+import { E as EmberTesting } from '../shared-chunks/public-api-C3KlJmEr.js';
+import { registerTestImplementation } from '../@ember/test/index.js';
+export { default as Adapter } from './lib/adapters/adapter.js';
+export { default as Test } from './lib/test.js';
+
+registerTestImplementation(EmberTesting);

package/dist/prod/packages/ember-testing/lib/adapters/adapter.js

@@ -0,0 +1,49 @@
+import EmberObject from '../../../@ember/object/index.js';
+
+/**
+ @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
+*/
+
+const Adapter = 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() {},
+  /**
+    This callback will be called whenever an async operation has completed.
+     @public
+    @method asyncEnd
+  */
+  asyncEnd() {},
+  /**
+    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;
+  }
+});
+
+export { Adapter as default };

package/dist/prod/packages/ember-testing/lib/public-api.js

@@ -0,0 +1,2 @@
+export { default as Test } from './test.js';
+export { default as Adapter } from './adapters/adapter.js';

package/dist/prod/packages/ember-testing/lib/test/adapter.js

@@ -0,0 +1,32 @@
+import { setDispatchOverride } from '../../../@ember/-internals/error-handling/index.js';
+
+let adapter;
+function getAdapter() {
+  return adapter;
+}
+function setAdapter(value) {
+  adapter = value;
+  if (value && typeof value.exception === 'function') {
+    setDispatchOverride(adapterDispatch);
+  } else {
+    setDispatchOverride(null);
+  }
+}
+function asyncStart() {
+  if (adapter) {
+    adapter.asyncStart();
+  }
+}
+function asyncEnd() {
+  if (adapter) {
+    adapter.asyncEnd();
+  }
+}
+function adapterDispatch(error) {
+  adapter.exception(error);
+
+  // @ts-expect-error Normally unreachable
+  console.error(error.stack); // eslint-disable-line no-console
+}
+
+export { asyncEnd, asyncStart, getAdapter, setAdapter };

package/dist/prod/packages/ember-testing/lib/test/pending_requests.js

@@ -0,0 +1,10 @@
+/* TODO: Remove this file
+ *  This is long unused but was being checked by @ember/test-helpers
+ *  so we are maintaining the file and method for now so as to
+ *  maintain compatibility with many versions of @ember/test-helpers
+ * */
+function pendingRequests() {
+  return 0; // hardcoded as this was unused but the method and file must stay for @ember/test-helpers compatibility
+}
+
+export { pendingRequests };

package/dist/prod/packages/ember-testing/lib/test/waiters.js

@@ -0,0 +1,128 @@
+/**
+ @module @ember/test
+*/
+const contexts = [];
+const callbacks = [];
+
+/**
+   This allows ember-testing to play nicely with other asynchronous
+   events, such as an application that is waiting for a CSS3
+   transition or an IndexDB transaction. The waiter runs periodically
+   after each async helper (i.e. `click`, `andThen`, `visit`, etc) has executed,
+   until the returning result is truthy. After the waiters finish, the next async helper
+   is executed and the process repeats.
+
+   For example:
+
+   ```javascript
+   import { registerWaiter } from '@ember/test';
+
+   registerWaiter(function() {
+     return myPendingTransactions() === 0;
+   });
+   ```
+   The `context` argument allows you to optionally specify the `this`
+   with which your callback will be invoked.
+
+   For example:
+
+   ```javascript
+   import { registerWaiter } from '@ember/test';
+
+   registerWaiter(MyDB, MyDB.hasPendingTransactions);
+   ```
+
+   @public
+   @for @ember/test
+   @static
+   @method registerWaiter
+   @param {Object} context (optional)
+   @param {Function} callback
+   @since 1.2.0
+*/
+
+function registerWaiter(
+// Formatting makes a pretty big difference in how readable this is.
+// prettier-ignore
+...args) {
+  let checkedCallback;
+  let checkedContext;
+  if (args.length === 1) {
+    checkedContext = null;
+    checkedCallback = args[0];
+  } else {
+    checkedContext = args[0];
+    checkedCallback = args[1];
+  }
+  if (indexOf(checkedContext, checkedCallback) > -1) {
+    return;
+  }
+  contexts.push(checkedContext);
+  callbacks.push(checkedCallback);
+}
+
+/**
+   `unregisterWaiter` is used to unregister a callback that was
+   registered with `registerWaiter`.
+
+   @public
+   @for @ember/test
+   @static
+   @method unregisterWaiter
+   @param {Object} context (optional)
+   @param {Function} callback
+   @since 1.2.0
+*/
+function unregisterWaiter(context, callback) {
+  if (!callbacks.length) {
+    return;
+  }
+  if (arguments.length === 1) {
+    callback = context;
+    context = null;
+  }
+  let i = indexOf(context, callback);
+  if (i === -1) {
+    return;
+  }
+  contexts.splice(i, 1);
+  callbacks.splice(i, 1);
+}
+
+/**
+  Iterates through each registered test waiter, and invokes
+  its callback. If any waiter returns false, this method will return
+  true indicating that the waiters have not settled yet.
+
+  This is generally used internally from the acceptance/integration test
+  infrastructure.
+
+  @public
+  @for @ember/test
+  @static
+  @method checkWaiters
+*/
+function checkWaiters() {
+  if (!callbacks.length) {
+    return false;
+  }
+  for (let i = 0; i < callbacks.length; i++) {
+    let context = contexts[i];
+    let callback = callbacks[i];
+    // SAFETY: The loop ensures that this exists
+    if (!callback.call(context)) {
+      return true;
+    }
+  }
+  return false;
+}
+function indexOf(context, callback) {
+  for (let i = 0; i < callbacks.length; i++) {
+    if (callbacks[i] === callback && contexts[i] === context) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+export { checkWaiters, registerWaiter, unregisterWaiter };

package/dist/prod/packages/ember-testing/lib/test.js

@@ -0,0 +1,25 @@
+import { checkWaiters, unregisterWaiter, registerWaiter } from './test/waiters.js';
+
+/**
+  @module ember
+*/
+
+/**
+  This is a container for an assortment of testing related functionality:
+
+  * Choose your default test adapter (for your framework of choice).
+  * Register/Unregister additional test helpers.
+  * Setup callbacks to be fired when the test helpers are injected into
+    your application.
+
+  @class Test
+  @namespace Ember
+  @public
+*/
+const Test = {
+  registerWaiter,
+  unregisterWaiter,
+  checkWaiters
+};
+
+export { Test as default };