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

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

@@ -0,0 +1,124 @@
+import { FrameworkObject } from '../object/-internals.js';
+import { deprecateUntil, DEPRECATIONS } from '../-internals/deprecations/index.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import '../../shared-chunks/observers-R1ZklwWy.js';
+import { i as inject$1 } from '../../shared-chunks/injected_property-DL3vQoFA.js';
+
+/**
+ @module @ember/service
+ @public
+ */
+
+/**
+  @method inject
+  @static
+  @since 1.10.0
+  @for @ember/service
+  @param {String} name (optional) name of the service to inject, defaults to
+         the property's name
+  @return {ComputedDecorator} injection decorator instance
+  @public
+  @deprecated Please import `service` instead.
+*/
+
+function inject(...args) {
+  deprecateUntil('Importing `inject` from `@ember/service` is deprecated. Please import `service` instead.', DEPRECATIONS.DEPRECATE_IMPORT_INJECT);
+  return inject$1('service', ...args);
+}
+
+/**
+  Creates a property that lazily looks up a service in the container. There are
+  no restrictions as to what objects a service can be injected into.
+
+  Example:
+
+  ```app/routes/application.js
+  import Route from '@ember/routing/route';
+  import { service } from '@ember/service';
+
+  export default class ApplicationRoute extends Route {
+    @service('auth') authManager;
+
+    model() {
+      return this.authManager.findCurrentUser();
+    }
+  }
+  ```
+
+  Classic Class Example:
+
+  ```app/routes/application.js
+  import Route from '@ember/routing/route';
+  import { service } from '@ember/service';
+
+  export default class ApplicationRoute extends Route {
+    @service('auth') authManager;
+
+    model() {
+      return this.authManager.findCurrentUser();
+    }
+  }
+  ```
+
+  This example will create an `authManager` property on the application route
+  that looks up the `auth` service in the container, making it easily accessible
+  in the `model` hook.
+
+  @method service
+  @static
+  @since 4.1.0
+  @for @ember/service
+  @param {String} name (optional) name of the service to inject, defaults to
+         the property's name
+  @return {ComputedDecorator} injection decorator instance
+  @public
+*/
+
+function service(...args) {
+  return inject$1('service', ...args);
+}
+
+/**
+  @class Service
+  @extends EmberObject
+  @since 1.10.0
+  @public
+*/
+class Service extends FrameworkObject {
+  static isServiceFactory = true;
+}
+
+/**
+  A type registry for Ember `Service`s. Meant to be declaration-merged so string
+  lookups resolve to the correct type.
+
+  Blueprints should include such a declaration merge for TypeScript:
+
+  ```ts
+  import Service from '@ember/service';
+
+  export default class ExampleService extends Service {
+    // ...
+  }
+
+  declare module '@ember/service' {
+    export interface Registry {
+      example: ExampleService;
+    }
+  }
+  ```
+
+  Then `@service` can check that the service is registered correctly, and APIs
+  like `owner.lookup('service:example')` can return `ExampleService`.
+ */
+// NOTE: this cannot be `Record<string, Service | undefined>`, convenient as
+// that would be for end users, because there is no actual contract to that
+// effect with Ember -- and in the future this choice would allow us to have
+// registered services which have no base class.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+export { Service as default, inject, service };

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

@@ -0,0 +1,12 @@
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/index-CSVCFS_p.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+export { d as htmlSafe, i as isHTMLSafe, e as isTrustedHTML, t as trustHTML } from '../../shared-chunks/index-DZLHQAlb.js';
+import '../-internals/container/index.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import '../../shared-chunks/on-CrTl7JQU.js';
+import '../../shared-chunks/constants-b-2IVErl.js';
+import '../runloop/index.js';

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

@@ -0,0 +1,20 @@
+// (UN)SAFETY: the public API is that people can import and use this (and indeed
+// it is emitted as part of Ember's build!), so we define it as having the type
+// which makes that work. However, in practice it is supplied by the build,
+// *for* the build, and will *not* be present at runtime, so the actual value
+// here is `undefined` in prod; in dev it is a function which throws a somewhat
+// nicer error. This is janky, but... here we are.
+
+let __emberTemplateCompiler;
+const compileTemplate = (...args) => {
+  if (!__emberTemplateCompiler) {
+    throw new Error('Attempted to call `compileTemplate` without first loading the runtime template compiler.');
+  }
+  return __emberTemplateCompiler.compile(...args);
+};
+let precompileTemplate;
+function __registerTemplateCompiler(c) {
+  __emberTemplateCompiler = c;
+}
+
+export { __emberTemplateCompiler, __registerTemplateCompiler, compileTemplate, precompileTemplate };

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

@@ -0,0 +1 @@
+export { INTERNAL_PLUGINS, RESOLUTION_MODE_TRANSFORMS, STRICT_MODE_KEYWORDS, STRICT_MODE_TRANSFORMS } from './lib/plugins/index.js';

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

@@ -0,0 +1 @@
+export { inScope, isPath, isStringLiteral, isSubExpression, trackLocals } from './lib/plugins/utils.js';

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

@@ -0,0 +1,2 @@
+export { template } from './lib/template.js';
+export { ALLOWED_GLOBALS } from './lib/plugins/allowed-globals.js';

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

@@ -0,0 +1 @@
+export { INTERNAL_PLUGINS, RESOLUTION_MODE_TRANSFORMS, STRICT_MODE_KEYWORDS, STRICT_MODE_TRANSFORMS } from '../plugins/index.js';

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

@@ -0,0 +1,103 @@
+import '../../-internals/environment/index.js';
+import { STRICT_MODE_KEYWORDS, STRICT_MODE_TRANSFORMS, RESOLUTION_MODE_TRANSFORMS } from './plugins/index.js';
+import { ALLOWED_GLOBALS } from './plugins/allowed-globals.js';
+import COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE from './dasherize-component-name.js';
+
+let USER_PLUGINS = [];
+function buildCompileOptions(_options) {
+  let moduleName = _options.moduleName;
+  let options = {
+    meta: {},
+    isProduction: false,
+    plugins: {
+      ast: []
+    },
+    ..._options,
+    moduleName,
+    customizeComponentName(tagname) {
+      return COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get(tagname);
+    }
+  };
+  if ('eval' in options) {
+    const localScopeEvaluator = options.eval;
+    const globalScopeEvaluator = value => new Function(`return ${value};`)();
+    options.lexicalScope = variable => {
+      if (ALLOWED_GLOBALS.has(variable)) {
+        return variable in globalThis;
+      }
+      if (inScope(variable, localScopeEvaluator)) {
+        return !inScope(variable, globalScopeEvaluator);
+      }
+      return false;
+    };
+    delete options.eval;
+  }
+  if ('scope' in options) {
+    const scope = options.scope();
+    options.lexicalScope = variable => {
+      return variable in scope;
+    };
+    delete options.scope;
+  }
+  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, ...pluginsToAdd];
+  }
+  return options;
+}
+// https://tc39.es/ecma262/2020/#prod-IdentifierName
+const IDENT = /^[\p{ID_Start}$_][\p{ID_Continue}$_\u200C\u200D]*$/u;
+function inScope(variable, evaluator) {
+  // If the identifier is not a valid JS identifier, it's definitely not in scope
+  if (!IDENT.exec(variable)) {
+    return false;
+  }
+  try {
+    return evaluator(`typeof ${variable} !== "undefined"`) === true;
+  } catch (e) {
+    // This occurs when attempting to evaluate a reserved word using eval (`eval('typeof let')`).
+    // If the variable is a reserved word, it's definitely not in scope, so return false. Since
+    // reserved words are somewhat contextual, we don't try to identify them purely by their
+    // name. See https://tc39.es/ecma262/#sec-keywords-and-reserved-words
+    if (e && e instanceof SyntaxError) {
+      return false;
+    }
+
+    // If it's another kind of error, don't swallow it.
+    throw e;
+  }
+}
+
+export { compileOptions as default };

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

@@ -0,0 +1,21 @@
+import '../../../shared-chunks/super-Cm_a_cLQ.js';
+import { C as Cache } from '../../../shared-chunks/cache-qDyqAcpg.js';
+import '../../-internals/environment/index.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()}`;
+}));
+
+export { COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE as default };

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

@@ -0,0 +1,56 @@
+/**
+ * @private
+ *
+ * RFC: https://github.com/emberjs/rfcs/pull/1070
+ *
+ * Criteria for inclusion in this list:
+ *
+ *   Any of:
+ *     - begins with an uppercase letter
+ *     - guaranteed to never be added to glimmer as a keyword (e.g.: globalThis)
+ *
+ *   And:
+ *     - must not need new to invoke
+ *     - must not require lifetime management (e.g.: setTimeout)
+ *     - must not be a single-word lower-case API, because of potential collision with future new HTML elements
+ *     - if the API is a function, the return value should not be a promise
+ *     - must be one one of these lists:
+ *        - https://tc39.es/ecma262/#sec-global-object
+ *        - https://tc39.es/ecma262/#sec-function-properties-of-the-global-object
+ *        - https://html.spec.whatwg.org/multipage/nav-history-apis.html#window
+ *        - https://html.spec.whatwg.org/multipage/indices.html#all-interfaces
+ *        - https://html.spec.whatwg.org/multipage/webappapis.html
+ */
+const ALLOWED_GLOBALS = new Set([
+// ////////////////
+// namespaces
+// ////////////////
+//   TC39
+'globalThis', 'Atomics', 'JSON', 'Math', 'Reflect',
+//   WHATWG
+'localStorage', 'sessionStorage', 'URL',
+// ////////////////
+// functions / utilities
+// ////////////////
+//   TC39
+'isNaN', 'isFinite', 'parseInt', 'parseFloat', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent',
+//   WHATWG
+'postMessage', 'structuredClone',
+// ////////////////
+// new-less Constructors (still functions)
+// ////////////////
+//   TC39
+'Array',
+// different behavior from (array)
+'BigInt', 'Boolean', 'Date', 'Number', 'Object',
+// different behavior from (hash)
+'String',
+// ////////////////
+// Values
+// ////////////////
+//   TC39
+'Infinity', 'NaN',
+//   WHATWG
+'isSecureContext']);
+
+export { ALLOWED_GLOBALS };

package/dist/prod/packages/@ember/template-compiler/lib/plugins/assert-against-attrs.js

@@ -0,0 +1,49 @@
+import '../../../-internals/environment/index.js';
+import { trackLocals } from './utils.js';
+
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that asserts against
+
+  ```handlebars
+  {{attrs.foo.bar}}
+  ```
+
+  ...as well as `{{#if attrs.foo}}`, `{{deeply (nested attrs.foobar.baz)}}`.
+
+  @private
+  @class AssertAgainstAttrs
+*/
+
+function assertAgainstAttrs(env) {
+  let {
+    builders: b
+  } = env.syntax;
+  env.meta?.moduleName;
+  let {
+    hasLocal,
+    visitor
+  } = trackLocals(env);
+  return {
+    name: 'assert-against-attrs',
+    visitor: {
+      ...visitor,
+      PathExpression(node) {
+        if (isAttrs(node, hasLocal)) ; else if (isThisDotAttrs(node)) {
+          return b.path(`@${node.original.slice(11)}`, node.loc);
+        }
+      }
+    }
+  };
+}
+function isAttrs(node, hasLocal) {
+  return node.head.type === 'VarHead' && node.head.name === 'attrs' && !hasLocal(node.head.name);
+}
+function isThisDotAttrs(node) {
+  return node.head.type === 'ThisHead' && node.tail[0] === 'attrs';
+}
+
+export { assertAgainstAttrs as default };

package/dist/prod/packages/@ember/template-compiler/lib/plugins/assert-against-named-outlets.js

@@ -0,0 +1,34 @@
+import '../../../-internals/environment/index.js';
+import calculateLocationDisplay from '../system/calculate-location-display.js';
+import { trackLocals } from './utils.js';
+
+/**
+ @module ember
+*/
+
+/**
+  Prevents usage of named outlets, a legacy concept in Ember removed in 4.0.
+
+  @private
+  @class AssertAgainstNamedOutlets
+*/
+function assertAgainstNamedOutlets(env) {
+  let moduleName = env.meta?.moduleName;
+  let {
+    hasLocal,
+    visitor
+  } = trackLocals(env);
+  return {
+    name: 'assert-against-named-outlets',
+    visitor: {
+      ...visitor,
+      MustacheStatement(node) {
+        if (node.path.type === 'PathExpression' && node.path.original === 'outlet' && node.params[0] && !hasLocal('outlet')) {
+          calculateLocationDisplay(moduleName, node.loc);
+        }
+      }
+    }
+  };
+}
+
+export { assertAgainstNamedOutlets as default };

package/dist/prod/packages/@ember/template-compiler/lib/plugins/assert-input-helper-without-block.js

@@ -0,0 +1,22 @@
+import '../../../-internals/environment/index.js';
+import { isPath, trackLocals } from './utils.js';
+
+function errorOnInputWithContent(env) {
+  env.meta?.moduleName;
+  let {
+    hasLocal,
+    visitor
+  } = trackLocals(env);
+  return {
+    name: 'assert-input-helper-without-block',
+    visitor: {
+      ...visitor,
+      BlockStatement(node) {
+        if (hasLocal('input')) return;
+        if (isPath(node.path) && node.path.original === 'input') ;
+      }
+    }
+  };
+}
+
+export { errorOnInputWithContent as default };

package/dist/prod/packages/@ember/template-compiler/lib/plugins/assert-reserved-named-arguments.js

@@ -0,0 +1,37 @@
+import '../../../-internals/environment/index.js';
+
+function assertReservedNamedArguments(env) {
+  env.meta?.moduleName;
+  return {
+    name: 'assert-reserved-named-arguments',
+    visitor: {
+      // In general, we don't assert on the invocation side to avoid creating migration
+      // hazards (e.g. using angle bracket to invoke a classic component that uses
+      // `this.someReservedName`. However, we want to avoid leaking special internal
+      // things, such as `__ARGS__`, so those would need to be asserted on both sides.
+
+      AttrNode({
+        name,
+        loc
+      }) {
+      },
+      HashPair({
+        key,
+        loc
+      }) {
+      },
+      PathExpression({
+        original,
+        loc
+      }) {
+        if (isReserved(original)) ;
+      }
+    }
+  };
+}
+const RESERVED = ['@arguments', '@args', '@block', '@else'];
+function isReserved(name) {
+  return RESERVED.indexOf(name) !== -1 || Boolean(name.match(/^@[^a-z]/));
+}
+
+export { assertReservedNamedArguments as default };

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

@@ -7,7 +7,7 @@ import transformEachInIntoEach from './transform-each-in-into-each.js';
 import transformEachTrackArray from './transform-each-track-array.js';
 import transformInElement from './transform-in-element.js';
 import transformQuotedBindingsIntoJustBindings from './transform-quoted-bindings-into-just-bindings.js';
-import { t as transformResolutions } from '../../../../shared-chunks/transform-resolutions-vHYYonpB.js';
+import { Z as transformResolutions } from '../../../../shared-chunks/transform-resolutions-C7wq_Q_c.js';
 import transformWrapMountAndOutlet from './transform-wrap-mount-and-outlet.js';
 
 const INTERNAL_PLUGINS = {

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

@@ -0,0 +1,65 @@
+import { trackLocals, isPath } from './utils.js';
+
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that replaces all instances of
+
+  ```handlebars
+ <button {{action 'foo'}}>
+ <button onblur={{action 'foo'}}>
+ <button onblur={{action (action 'foo') 'bar'}}>
+  ```
+
+  with
+
+  ```handlebars
+ <button {{action this 'foo'}}>
+ <button onblur={{action this 'foo'}}>
+ <button onblur={{action this (action this 'foo') 'bar'}}>
+  ```
+
+  @private
+  @class TransformActionSyntax
+*/
+
+function transformActionSyntax(env) {
+  let {
+    builders: b
+  } = env.syntax;
+  let {
+    hasLocal,
+    visitor
+  } = trackLocals(env);
+  return {
+    name: 'transform-action-syntax',
+    visitor: {
+      ...visitor,
+      ElementModifierStatement(node) {
+        if (isAction(node, hasLocal)) {
+          insertThisAsFirstParam(node, b);
+        }
+      },
+      MustacheStatement(node) {
+        if (isAction(node, hasLocal)) {
+          insertThisAsFirstParam(node, b);
+        }
+      },
+      SubExpression(node) {
+        if (isAction(node, hasLocal)) {
+          insertThisAsFirstParam(node, b);
+        }
+      }
+    }
+  };
+}
+function isAction(node, hasLocal) {
+  return isPath(node.path) && node.path.original === 'action' && !hasLocal('action');
+}
+function insertThisAsFirstParam(node, builders) {
+  node.params.unshift(builders.path('this'));
+}
+
+export { transformActionSyntax as default };

package/dist/prod/packages/@ember/template-compiler/lib/plugins/transform-each-in-into-each.js

@@ -0,0 +1,51 @@
+import { isPath } from './utils.js';
+
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that replaces all instances of
+
+  ```handlebars
+  {{#each-in iterableThing as |key value|}}
+  ```
+
+  with
+
+  ```handlebars
+  {{#each (-each-in iterableThing) as |value key|}}
+  ```
+
+  @private
+  @class TransformHasBlockSyntax
+*/
+function transformEachInIntoEach(env) {
+  let {
+    builders: b
+  } = env.syntax;
+  return {
+    name: 'transform-each-in-into-each',
+    visitor: {
+      BlockStatement(node) {
+        if (isPath(node.path) && node.path.original === 'each-in') {
+          node.params[0] = b.sexpr(b.path('-each-in'), [node.params[0]]);
+          let blockParams = node.program.blockParams;
+          if (!blockParams || blockParams.length === 0) ; else if (blockParams.length === 1) {
+            // insert a dummy variable for the first slot
+            // pick a name that won't parse so it won't shadow any real variables
+            blockParams = ['( unused value )', blockParams[0]];
+          } else {
+            let key = blockParams.shift();
+            let value = blockParams.shift();
+            blockParams = [value, key, ...blockParams];
+          }
+          node.program.blockParams = blockParams;
+          return b.block(b.path('each'), node.params, node.hash, node.program, node.inverse, node.loc);
+        }
+      }
+    }
+  };
+}
+
+export { transformEachInIntoEach as default };

package/dist/prod/packages/@ember/template-compiler/lib/plugins/transform-each-track-array.js

@@ -0,0 +1,50 @@
+import '../../../-internals/environment/index.js';
+import { isPath, trackLocals } from './utils.js';
+
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that replaces all instances of
+
+  ```handlebars
+  {{#each iterableThing as |key value|}}
+  ```
+
+  with
+
+  ```handlebars
+  {{#each (-track-array iterableThing) as |key value|}}
+  ```
+
+  @private
+  @class TransformHasBlockSyntax
+*/
+function transformEachTrackArray(env) {
+  let {
+    builders: b
+  } = env.syntax;
+  let {
+    hasLocal,
+    visitor
+  } = trackLocals(env);
+  return {
+    name: 'transform-each-track-array',
+    visitor: {
+      ...visitor,
+      BlockStatement(node) {
+        if (isPath(node.path) && node.path.original === 'each' && !hasLocal('each')) {
+          let firstParam = node.params[0];
+          if (firstParam.type === 'SubExpression' && firstParam.path.type === 'PathExpression' && firstParam.path.original === '-each-in') {
+            return;
+          }
+          node.params[0] = b.sexpr(b.path('-track-array'), [firstParam]);
+          return b.block(b.path('each'), node.params, node.hash, node.program, node.inverse, node.loc);
+        }
+      }
+    }
+  };
+}
+
+export { transformEachTrackArray as default };