ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/{packages → prod/packages}/@ember/template-compiler/lib/plugins/transform-in-element.js

@@ -1,8 +1,24 @@
-import '../../../debug/index.js';
+import '../../../-internals/environment/index.js';
 import { isPath } from './utils.js';
-import { isDevelopingApp } from '@embroider/macros';
-import { assert } from '../../../debug/lib/assert.js';
 
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that handles the public `{{in-element}}` as per RFC287.
+
+  Issues a build time assertion for:
+
+  ```handlebars
+  {{#in-element someElement insertBefore="some-none-null-value"}}
+    {{modal-display text=text}}
+  {{/in-element}}
+  ```
+
+  @private
+  @class TransformInElement
+*/
 function transformInElement(env) {
   let {
     builders: b
@@ -20,9 +36,7 @@ function transformInElement(env) {
             node.params.unshift(subExpr);
           }
           node.hash.pairs.forEach(pair => {
-            if (pair.key === 'insertBefore') {
-              (isDevelopingApp() && !(pair.value.type === 'NullLiteral' || pair.value.type === 'UndefinedLiteral') && assert(`Can only pass null to insertBefore in in-element, received: ${JSON.stringify(pair.value)}`, pair.value.type === 'NullLiteral' || pair.value.type === 'UndefinedLiteral'));
-            }
+            if (pair.key === 'insertBefore') ;
           });
         }
       }

package/dist/prod/packages/@ember/template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.js

@@ -0,0 +1,37 @@
+function transformQuotedBindingsIntoJustBindings(/* env */
+) {
+  return {
+    name: 'transform-quoted-bindings-into-just-bindings',
+    visitor: {
+      ElementNode(node) {
+        let styleAttr = getStyleAttr(node);
+        if (!validStyleAttr(styleAttr)) {
+          return;
+        }
+        styleAttr.value = styleAttr.value.parts[0];
+      }
+    }
+  };
+}
+function validStyleAttr(attr) {
+  if (!attr) {
+    return false;
+  }
+  let value = attr.value;
+  if (!value || value.type !== 'ConcatStatement' || value.parts.length !== 1) {
+    return false;
+  }
+  let onlyPart = value.parts[0];
+  return onlyPart.type === 'MustacheStatement';
+}
+function getStyleAttr(node) {
+  let attributes = node.attributes;
+  for (let attribute of attributes) {
+    if (attribute.name === 'style') {
+      return attribute;
+    }
+  }
+  return undefined;
+}
+
+export { transformQuotedBindingsIntoJustBindings as default };

package/dist/prod/packages/@ember/template-compiler/lib/plugins/transform-resolutions.js

@@ -0,0 +1,4 @@
+import '../../../-internals/environment/index.js';
+export { Z as default } from '../../../../shared-chunks/transform-resolutions-C7wq_Q_c.js';
+import '../../../../@glimmer/wire-format/index.js';
+import './utils.js';

package/dist/prod/packages/@ember/template-compiler/lib/plugins/transform-wrap-mount-and-outlet.js

@@ -0,0 +1,57 @@
+import { isPath, trackLocals } from './utils.js';
+
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that replaces all instances of
+
+  ```handlebars
+  {{mount "engine" model=this.model}}
+  ```
+
+  with
+
+  ```handlebars
+  {{component (-mount "engine" model=this.model)}}
+  ```
+
+  and
+
+  ```handlebars
+  {{outlet}}
+  ```
+
+  with
+
+  ```handlebars
+  {{component (-outlet)}}
+  ```
+
+  @private
+  @class TransformHasBlockSyntax
+*/
+function transformWrapMountAndOutlet(env) {
+  let {
+    builders: b
+  } = env.syntax;
+  let {
+    hasLocal,
+    visitor
+  } = trackLocals(env);
+  return {
+    name: 'transform-wrap-mount-and-outlet',
+    visitor: {
+      ...visitor,
+      MustacheStatement(node) {
+        if (isPath(node.path) && (node.path.original === 'mount' || node.path.original === 'outlet') && !hasLocal(node.path.original)) {
+          let subexpression = b.sexpr(b.path(`-${node.path.original}`), node.params, node.hash, node.loc);
+          return b.mustache(b.path('component'), [subexpression], b.hash(), undefined, node.loc);
+        }
+      }
+    }
+  };
+}
+
+export { transformWrapMountAndOutlet as default };

package/dist/prod/packages/@ember/template-compiler/lib/plugins/utils.js

@@ -0,0 +1,55 @@
+function isPath(node) {
+  return node.type === 'PathExpression';
+}
+function isSubExpression(node) {
+  return node.type === 'SubExpression';
+}
+function isStringLiteral(node) {
+  return node.type === 'StringLiteral';
+}
+function inScope(env, name) {
+  return Boolean(env.lexicalScope?.(name));
+}
+function getLocalName(node) {
+  if (typeof node === 'string') {
+    return node;
+  } else {
+    return node.original;
+  }
+}
+function trackLocals(env) {
+  let locals = new Map();
+  let node = {
+    enter(node) {
+      let params = 'params' in node ? node.params : node.blockParams;
+      for (let param of params) {
+        let name = getLocalName(param);
+        let value = locals.get(param) || 0;
+        locals.set(name, value + 1);
+      }
+    },
+    exit(node) {
+      let params = 'params' in node ? node.params : node.blockParams;
+      for (let param of params) {
+        let name = getLocalName(param);
+        let value = locals.get(name) - 1;
+        if (value === 0) {
+          locals.delete(name);
+        } else {
+          locals.set(name, value);
+        }
+      }
+    }
+  };
+  return {
+    hasLocal: key => locals.has(key) || inScope(env, key),
+    node,
+    visitor: {
+      Template: node,
+      ElementNode: node,
+      Block: node
+    }
+  };
+}
+
+export { inScope, isPath, isStringLiteral, isSubExpression, trackLocals };

package/dist/prod/packages/@ember/template-compiler/lib/public-api.js

@@ -0,0 +1 @@
+export { template } from './template.js';

package/dist/prod/packages/@ember/template-compiler/lib/runtime.js

@@ -0,0 +1 @@
+export { template } from './template.js';

package/dist/prod/packages/@ember/template-compiler/lib/system/calculate-location-display.js

@@ -0,0 +1,28 @@
+function calculateLocationDisplay(moduleName, loc) {
+  let moduleInfo = '';
+  if (moduleName) {
+    moduleInfo += `'${moduleName}' `;
+  }
+  if (loc) {
+    let {
+      column,
+      line
+    } = loc.start || {
+      line: undefined,
+      column: undefined
+    };
+    if (line !== undefined && column !== undefined) {
+      if (moduleName) {
+        // only prepend @ if the moduleName was present
+        moduleInfo += '@ ';
+      }
+      moduleInfo += `L${line}:C${column}`;
+    }
+  }
+  if (moduleInfo) {
+    moduleInfo = `(${moduleInfo}) `;
+  }
+  return moduleInfo;
+}
+
+export { calculateLocationDisplay as default };

package/dist/prod/packages/@ember/template-compiler/lib/template.js

@@ -0,0 +1,245 @@
+import './plugins/allowed-globals.js';
+import templateOnly from '../../component/template-only.js';
+import '../../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../../@glimmer/wire-format/index.js';
+import { p as precompile } from '../../../shared-chunks/compiler-Ddfo5StE.js';
+import '../../../@glimmer/validator/index.js';
+import '../../../shared-chunks/reference-BNqcwZWH.js';
+import '../../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { s as setComponentTemplate } from '../../../shared-chunks/template-Dc_cBOoX.js';
+import { t as templateFactory } from '../../../shared-chunks/index-CSVCFS_p.js';
+import compileOptions from './compile-options.js';
+
+/**
+ * All possible options passed to `template()` may specify a `moduleName`.
+ */
+
+/**
+ * When using `template` in a class, you call it in a `static` block and pass
+ * the class as the `component` option.
+ *
+ * ```ts
+ * class MyComponent extends Component {
+ *   static {
+ *     template('{{this.greeting}}, {{@place}}!',
+ *       { component: this },
+ *       // explicit or implicit option goes here
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * For the full explicit form, see {@linkcode ExplicitClassOptions}. For the
+ * full implicit form, see {@linkcode ImplicitClassOptions}.
+ */
+
+/**
+ * When using `template` outside of a class (i.e. a "template-only component"), you can pass
+ * a `scope` option that explicitly provides the lexical scope for the template.
+ *
+ * This is called the "explicit form".
+ *
+ * ```ts
+ * const greeting = 'Hello';
+ * const HelloWorld = template('{{greeting}} World!', { scope: () => ({ greeting }) });
+ * ```
+ */
+
+/**
+ * When using `template` *inside* a class (see
+ * {@linkcode BaseClassTemplateOptions}), you can pass a `scope` option that
+ * explicitly provides the lexical scope for the template, just like a template-only
+ * component (see {@linkcode ExplicitTemplateOnlyOptions}).
+ *
+ * ```ts
+ * class MyComponent extends Component {
+ *   static {
+ *     template('{{this.greeting}}, {{@place}}!',
+ *       { component: this },
+ *       // explicit or implicit option goes here
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * ## The Scope Function's `instance` Parameter
+ *
+ * However, the explicit `scope` function in a *class* also takes an `instance` option
+ * that provides access to the component's instance.
+ *
+ * Once it's supported in Handlebars, this will make it possible to represent private
+ * fields when using the explicit form.
+ *
+ * ```ts
+ * class MyComponent extends Component {
+ *   static {
+ *     template('{{this.#greeting}}, {{@place}}!',
+ *       { component: this },
+ *       scope: (instance) => ({ '#greeting': instance.#greeting }),
+ *     );
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * The *implicit* form of the `template` function takes an `eval` option that
+ * allows the runtime compiler to evaluate local template variables without
+ * needing to maintain an explicit list of the local variables used in the
+ * template scope.
+ *
+ * The eval options *must* be passed in the following form:
+ *
+ * ```ts
+ * {
+ *   eval() { return eval(arguments[0]) }
+ * }
+ * ```
+ *
+ * ## Requirements of the `eval` Option
+ *
+ * **The syntactic form presented above is the only form you should use when
+ * passing an `eval` option.**
+ *
+ * This is _required_ if you want your code to be compatible with the
+ * compile-time implementation of `@ember/template-compiler`. While the runtime
+ * compiler offers a tiny bit of additional wiggle room, you still need to follow
+ * very strict rules.
+ *
+ * We don't recommend trying to memorize the rules. Instead, we recommend using
+ * the snippet presented above and supported by the compile-time implementation.
+ *
+ * ### The Technical Requirements of the `eval` Option
+ *
+ * The `eval` function is passed a single parameter that is a JavaScript
+ * identifier. This will be extended in the future to support private fields.
+ *
+ * Since keywords in JavaScript are contextual (e.g. `await` and `yield`), the
+ * parameter might be a keyword. The `@ember/template-compiler/runtime` expects
+ * the function to throw a `SyntaxError` if the identifier name is not valid in
+ * the current scope. (The direct `eval` function takes care of this out of the
+ * box.)
+ *
+ * Requirements:
+ *
+ * 1. The `eval` method must receive its parameter as `arguments[0]`, which
+ *    ensures that the variable name passed to `eval()` is not shadowed by the
+ *    function's parameter name.
+ * 2. The `eval` option must be a function or concise method, and not an arrow.
+ *    This is because arrows do not have their own `arguments`, which breaks
+ *    (1).
+ * 3. The `eval` method must call "*direct* `eval`", and not an alias of `eval`.
+ *    Direct `eval` evaluates the code in the scope it was called from, while
+ *    aliased versions of `eval` (including `new Function`) evaluate the code in
+ *    the global scope.
+ * 4. The `eval` method must return the result of calling "direct `eval`".
+ *
+ * The easiest way to achieve these requirements is to use the exact syntax
+ * presented above. This is *also* the only way to be compatible
+ *
+ * ## Rationale
+ *
+ * This is useful for two reasons:
+ *
+ * 1. This form is a useful _intermediate_ form for the compile-time toolchain.
+ *    It allows the content-tag preprocessor to convert the `<template>` syntax
+ *    into valid JavaScript without needing to involve full-fledged lexical
+ *    analysis.
+ * 2. This form is a convenient form for manual prototyping when using the
+ *    runtime compiler directly. While it requires some extra typing relative to
+ *    `<template>`, it's a mechanical 1:1 transformation of the syntax.
+ *
+ * In practice, implementations that use a runtime compiler (for example, a
+ * playground running completely in the browser) should probably use the
+ * `content-tag` preprocessor to convert the template into the implicit form,
+ * and then rely on `@ember/template-compiler/runtime` to evaluate the template.
+ */
+
+/**
+ * When using `template` outside of a class (i.e. a "template-only component"), you can pass
+ * an `eval` option that _implicitly_ provides the lexical scope for the template.
+ *
+ * This is called the "implicit form".
+ *
+ * ```ts
+ * const greeting = 'Hello';
+ * const HelloWorld = template('{{greeting}} World!', {
+ *   eval() { return arguments[0] }
+ * });
+ * ```
+ *
+ * For more details on the requirements of the `eval` option, see {@linkcode ImplicitEvalOption}.
+ */
+
+/**
+ * When using `template` inside of a class, you can pass an `eval` option that
+ * _implicitly_ provides the lexical scope for the template, just as you can
+ * with a {@linkcode ImplicitTemplateOnlyOptions | template-only component}.
+ *
+ * This is called the "implicit form".
+ *
+ * ```ts
+ * class MyComponent extends Component {
+ *   static {
+ *     template('{{this.greeting}}, {{@place}}!',
+ *       { component: this },
+ *       eval() { return arguments[0] }
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * ## Note  on Private Fields
+ *
+ * The current implementation of `@ember/template-compiler` does not support
+ * private fields, but once the Handlebars parser adds support for private field
+ * syntax and it's implemented in the Glimmer compiler, the implicit form should
+ * be able to support them.
+ */
+
+function template(templateString, providedOptions) {
+  const options = {
+    strictMode: true,
+    ...providedOptions
+  };
+  const evaluate = buildEvaluator(options);
+  const normalizedOptions = compileOptions(options);
+  const component = normalizedOptions.component ?? templateOnly();
+  const source = precompile(templateString, normalizedOptions);
+  const template = templateFactory(evaluate(`(${source})`));
+  setComponentTemplate(template, component);
+  return component;
+}
+const evaluator = source => {
+  return new Function(`return  ${source}`)();
+};
+function buildEvaluator(options) {
+  if (options === undefined) {
+    return evaluator;
+  }
+  if (options.eval) {
+    return options.eval;
+  } else {
+    const scope = options.scope?.();
+    if (!scope) {
+      return evaluator;
+    }
+    return source => {
+      let hasThis = Object.prototype.hasOwnProperty.call(scope, 'this');
+      let thisValue = hasThis ? scope.this : undefined;
+      let argNames = [];
+      let argValues = [];
+      for (let [name, value] of Object.entries(scope)) {
+        if (name === 'this') {
+          continue;
+        }
+        argNames.push(name);
+        argValues.push(value);
+      }
+      let fn = new Function(...argNames, `return (${source})`);
+      return hasThis ? fn.call(thisValue, ...argValues) : fn(...argValues);
+    };
+  }
+}
+
+export { template };

package/dist/prod/packages/@ember/template-factory/index.js

@@ -0,0 +1,5 @@
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+export { t as createTemplateFactory } from '../../shared-chunks/index-CSVCFS_p.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';

package/dist/prod/packages/@ember/test/adapter.js

@@ -0,0 +1,2 @@
+import '../../ember-testing/index.js';
+export { default } from '../../ember-testing/lib/adapters/adapter.js';

package/dist/prod/packages/@ember/test/index.js

@@ -0,0 +1,18 @@
+let registerWaiter;
+let unregisterWaiter;
+let _impl;
+let testingNotAvailableMessage = () => {
+  throw new Error('Attempted to use test utilities, but `ember-testing` was not included');
+};
+registerWaiter = testingNotAvailableMessage;
+unregisterWaiter = testingNotAvailableMessage;
+function registerTestImplementation(impl) {
+  let {
+    Test
+  } = impl;
+  registerWaiter = Test.registerWaiter;
+  unregisterWaiter = Test.unregisterWaiter;
+  _impl = impl;
+}
+
+export { _impl, registerTestImplementation, registerWaiter, unregisterWaiter };

package/dist/prod/packages/@ember/utils/index.js

@@ -0,0 +1,7 @@
+export { default as isNone } from './lib/is_none.js';
+export { default as isBlank } from './lib/is_blank.js';
+export { default as isEmpty } from './lib/is_empty.js';
+export { default as isPresent } from './lib/is_present.js';
+export { default as isEqual } from './lib/is-equal.js';
+export { default as typeOf } from './lib/type-of.js';
+export { default as compare } from './lib/compare.js';

package/dist/prod/packages/@ember/utils/lib/compare.js

@@ -0,0 +1,159 @@
+import typeOf from './type-of.js';
+import '../../-internals/runtime/lib/mixins/registry_proxy.js';
+import '../../-internals/runtime/lib/mixins/container_proxy.js';
+import Comparable from '../../-internals/runtime/lib/mixins/comparable.js';
+import '../../-internals/runtime/lib/mixins/action_handler.js';
+import '../../-internals/runtime/lib/mixins/-proxy.js';
+import '../../enumerable/mutable.js';
+import '../../-internals/runtime/lib/mixins/target_action_support.js';
+import '../../-internals/runtime/lib/ext/rsvp.js';
+import '../../-internals/environment/index.js';
+
+const TYPE_ORDER = {
+  undefined: 0,
+  null: 1,
+  boolean: 2,
+  number: 3,
+  string: 4,
+  array: 5,
+  object: 6,
+  instance: 7,
+  function: 8,
+  class: 9,
+  date: 10,
+  regexp: 11,
+  filelist: 12,
+  error: 13
+};
+//
+// the spaceship operator
+//
+//                      `. ___
+//                     __,' __`.                _..----....____
+//         __...--.'``;.   ,.   ;``--..__     .'    ,-._    _.-'
+//   _..-''-------'   `'   `'   `'     O ``-''._   (,;') _,'
+// ,'________________                          \`-._`-','
+//  `._              ```````````------...___   '-.._'-:
+//     ```--.._      ,.                     ````--...__\-.
+//             `.--. `-` "INFINITY IS LESS     ____    |  |`
+//               `. `.   THAN BEYOND"        ,'`````.  ;  ;`
+//                 `._`.        __________   `.      \'__/`
+//                    `-:._____/______/___/____`.     \  `
+//                                |       `._    `.    \
+//                                `._________`-.   `.   `.___
+//                                              SSt  `------'`
+function spaceship(a, b) {
+  // SAFETY: `Math.sign` always returns `-1` for negative, `0` for zero, and `1`
+  // for positive numbers. (The extra precision is useful for the way we use
+  // this in the context of `compare`.)
+  return Math.sign(a - b);
+}
+
+/**
+ @module @ember/utils
+*/
+
+/**
+ Compares two javascript values and returns:
+
+  - -1 if the first is smaller than the second,
+  - 0 if both are equal,
+  - 1 if the first is greater than the second.
+
+  ```javascript
+  import { compare } from '@ember/utils';
+
+  compare('hello', 'hello');  // 0
+  compare('abc', 'dfg');      // -1
+  compare(2, 1);              // 1
+  ```
+
+ If the types of the two objects are different precedence occurs in the
+ following order, with types earlier in the list considered `<` types
+ later in the list:
+
+  - undefined
+  - null
+  - boolean
+  - number
+  - string
+  - array
+  - object
+  - instance
+  - function
+  - class
+  - date
+
+  ```javascript
+  import { compare } from '@ember/utils';
+
+  compare('hello', 50);       // 1
+  compare(50, 'hello');       // -1
+  ```
+
+ @method compare
+ @for @ember/utils
+ @static
+ @param {Object} v First value to compare
+ @param {Object} w Second value to compare
+ @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
+ @public
+*/
+function compare(v, w) {
+  if (v === w) {
+    return 0;
+  }
+  let type1 = typeOf(v);
+  let type2 = typeOf(w);
+  if (type1 === 'instance' && isComparable(v) && v.constructor.compare) {
+    return v.constructor.compare(v, w);
+  }
+  if (type2 === 'instance' && isComparable(w) && w.constructor.compare) {
+    // SAFETY: Multiplying by a negative just changes the sign
+    return w.constructor.compare(w, v) * -1;
+  }
+  let res = spaceship(TYPE_ORDER[type1], TYPE_ORDER[type2]);
+  if (res !== 0) {
+    return res;
+  }
+
+  // types are equal - so we have to check values now
+  switch (type1) {
+    case 'boolean':
+      return spaceship(Number(v), Number(w));
+    case 'number':
+      return spaceship(v, w);
+    case 'string':
+      return spaceship(v.localeCompare(w), 0);
+    case 'array':
+      {
+        let vLen = v.length;
+        let wLen = w.length;
+        let len = Math.min(vLen, wLen);
+        for (let i = 0; i < len; i++) {
+          let r = compare(v[i], w[i]);
+          if (r !== 0) {
+            return r;
+          }
+        }
+
+        // all elements are equal now
+        // shorter array should be ordered first
+        return spaceship(vLen, wLen);
+      }
+    case 'instance':
+      if (isComparable(v) && v.compare) {
+        return v.compare(v, w);
+      }
+      return 0;
+    case 'date':
+      return spaceship(v.getTime(), w.getTime());
+    default:
+      return 0;
+  }
+}
+function isComparable(value) {
+  return Comparable.detect(value);
+}
+
+export { compare as default };