ember-source 6.12.0 → 7.0.0-alpha.1

package/dist/prod/packages/@ember/-internals/deprecations/index.js

@@ -0,0 +1,114 @@
+import { ENV } from '../environment/index.js';
+import VERSION from '../../../ember/version.js';
+import { dasherize } from '../string/index.js';
+
+function isEnabled(options) {
+  return Object.hasOwnProperty.call(options.since, 'enabled') || ENV._ALL_DEPRECATIONS_ENABLED;
+}
+let numEmberVersion = parseFloat(ENV._OVERRIDE_DEPRECATION_VERSION ?? VERSION);
+
+/* until must only be a minor version or major version */
+function emberVersionGte(until, emberVersion = numEmberVersion) {
+  let significantUntil = until.replace(/(\.0+)/g, '');
+  return emberVersion >= parseFloat(significantUntil);
+}
+function isRemoved(options) {
+  return emberVersionGte(options.until);
+}
+function deprecation(options) {
+  return {
+    options,
+    test: !isEnabled(options),
+    isEnabled: isEnabled(options) || isRemoved(options),
+    isRemoved: isRemoved(options)
+  };
+}
+
+/*
+  To add a deprecation, you must add a new entry to the `DEPRECATIONS` object.
+  The entry should be an object with the following properties:
+
+  * `id` (required): A string that uniquely identifies the deprecation. This
+    should be a short, descriptive name, typically dasherized.
+  * `for` (required): The string `ember-source` -- every deprecation from this
+    package is for `ember-source`.
+  * `since` (required): An object with `available` and `enabled`. `available` is
+    the first version of Ember that the deprecation is available in. `enabled` is
+    the version of Ember that the deprecation was first enabled. This is used as
+    a feature flag deprecations. For public APIs, the `enabled` value is added
+    only once the deprecation RFC is [Ready for Release](https://github.com/emberjs/rfcs#ready-for-release).
+  * `until` (required): The version of Ember that the deprecation will be removed
+  * `url` (required): A URL to the deprecation guide for the deprecation. This
+    URL can be constructed in advance of the deprecation being added to the
+    [deprecation app](https://github.com/ember-learn/deprecation-app) by
+    following this format: `https://deprecations.emberjs.com/deprecations/{{id}}`.
+
+  For example:
+  `deprecate` should then be called using the entry from the `DEPRECATIONS` object.
+
+  ```ts
+  import { DEPRECATIONS } from '@ember/-internals/deprecations';
+  //...
+
+  deprecateUntil(message, DEPRECATIONS.MY_DEPRECATION);
+  ```
+
+  `expectDeprecation` should also use the DEPRECATIONS object, but it should be noted
+  that it uses `isEnabled` instead of `test` because the expectations of `expectDeprecation`
+  are the opposite of `test`.
+
+  ```ts
+  expectDeprecation(
+    () => {
+        assert.equal(foo, bar(), 'foo is equal to bar'); // something that triggers the deprecation
+    },
+    /matchesMessage/,
+    DEPRECATIONS.MY_DEPRECATION.isEnabled
+  );
+  ```
+
+  Tests can be conditionally run based on whether a deprecation is enabled or not:
+
+  ```ts
+    [`${testUnless(DEPRECATIONS.MY_DEPRECATION.isRemoved)} specific deprecated feature tested only in this test`]
+  ```
+
+  This test will be skipped when the MY_DEPRECATION is removed.
+  When adding a deprecation, we need to guard all the code that will eventually be removed, including tests.
+  For tests that are not specifically testing the deprecated feature, we need to figure out how to
+  test the behavior without encountering the deprecated feature, just as users would.
+ */
+const DEPRECATIONS = {
+  DEPRECATE_IMPORT_EMBER(importName) {
+    return deprecation({
+      id: `deprecate-import-${dasherize(importName).toLowerCase()}-from-ember`,
+      for: 'ember-source',
+      since: {
+        available: '5.10.0',
+        enabled: '6.5.0'
+      },
+      until: '7.0.0',
+      url: `https://deprecations.emberjs.com/id/import-${dasherize(importName).toLowerCase()}-from-ember`
+    });
+  },
+  DEPRECATE_IMPORT_INJECT: deprecation({
+    for: 'ember-source',
+    id: 'importing-inject-from-ember-service',
+    since: {
+      available: '6.2.0',
+      enabled: '6.3.0'
+    },
+    until: '7.0.0',
+    url: 'https://deprecations.emberjs.com/id/importing-inject-from-ember-service'
+  })
+};
+function deprecateUntil(message, deprecation) {
+  const {
+    options
+  } = deprecation;
+  if (deprecation.isRemoved) {
+    throw new Error(`The API deprecated by ${options.id} was removed in ember-source ${options.until}. The message was: ${message}. Please see ${options.url} for more details.`);
+  }
+}
+
+export { DEPRECATIONS, deprecateUntil, emberVersionGte, isRemoved };

package/dist/prod/packages/@ember/-internals/environment/index.js

@@ -0,0 +1,171 @@
+const global = globalThis;
+const Ember = global['Ember'];
+
+// legacy imports/exports/lookup stuff (should we keep this??)
+const context = Ember === undefined ? {
+  imports: global,
+  exports: global,
+  lookup: global
+} : {
+  // import jQuery
+  imports: Ember.imports || global,
+  // export Ember
+  exports: Ember.exports || global,
+  // search for Namespaces
+  lookup: Ember.lookup || global
+};
+function getLookup() {
+  return context.lookup;
+}
+function setLookup(value) {
+  context.lookup = value;
+}
+
+/**
+  The hash of environment variables used to control various configuration
+  settings. To specify your own or override default settings, add the
+  desired properties to a global hash named `EmberENV` (or `ENV` for
+  backwards compatibility with earlier versions of Ember). The `EmberENV`
+  hash must be created before loading Ember.
+
+  @class EmberENV
+  @type Object
+  @public
+*/
+const ENV = {
+  ENABLE_OPTIONAL_FEATURES: false,
+  /**
+    Determines whether Ember should add to `Array`
+    native object prototypes, a few extra methods in order to provide a more
+    friendly API.
+     The behavior from setting this option to `true` was deprecated in Ember 5.10.
+     @property EXTEND_PROTOTYPES
+    @type Boolean
+    @default true
+    @for EmberENV
+    @private
+    @deprecated in v5.10
+  */
+  EXTEND_PROTOTYPES: {
+    Array: false
+  },
+  /**
+    The `LOG_STACKTRACE_ON_DEPRECATION` property, when true, tells Ember to log
+    a full stack trace during deprecation warnings.
+     @property LOG_STACKTRACE_ON_DEPRECATION
+    @type Boolean
+    @default true
+    @for EmberENV
+    @public
+  */
+  LOG_STACKTRACE_ON_DEPRECATION: true,
+  /**
+    The `LOG_VERSION` property, when true, tells Ember to log versions of all
+    dependent libraries in use.
+     @property LOG_VERSION
+    @type Boolean
+    @default true
+    @for EmberENV
+    @public
+  */
+  LOG_VERSION: true,
+  RAISE_ON_DEPRECATION: false,
+  STRUCTURED_PROFILE: false,
+  /**
+    Whether to perform extra bookkeeping needed to make the `captureRenderTree`
+    API work.
+     This has to be set before the ember JavaScript code is evaluated. This is
+    usually done by setting `window.EmberENV = { _DEBUG_RENDER_TREE: true };`
+    before the "vendor" `<script>` tag in `index.html`.
+     Setting the flag after Ember is already loaded will not work correctly. It
+    may appear to work somewhat, but fundamentally broken.
+     This is not intended to be set directly. Ember Inspector will enable the
+    flag on behalf of the user as needed.
+     This flag is always on in development mode.
+     The flag is off by default in production mode, due to the cost associated
+    with the the bookkeeping work.
+     The expected flow is that Ember Inspector will ask the user to refresh the
+    page after enabling the feature. It could also offer a feature where the
+    user add some domains to the "always on" list. In either case, Ember
+    Inspector will inject the code on the page to set the flag if needed.
+     @property _DEBUG_RENDER_TREE
+    @for EmberENV
+    @type Boolean
+    @default false
+    @private
+  */
+  _DEBUG_RENDER_TREE: false /* DEBUG */,
+  /**
+   Whether to force all deprecations to be enabled. This is used internally by
+   Ember to enable deprecations in tests. It is not intended to be set in
+   projects.
+    @property _ALL_DEPRECATIONS_ENABLED
+   @for EmberENV
+   @type Boolean
+   @default false
+   @private
+   */
+  _ALL_DEPRECATIONS_ENABLED: false,
+  /**
+   Override the version of ember-source used to determine when deprecations "break".
+   This is used internally by Ember to test with deprecated features "removed".
+   This is never intended to be set by projects.
+   @property _OVERRIDE_DEPRECATION_VERSION
+   @for EmberENV
+   @type string | null
+   @default null
+   @private
+   */
+  _OVERRIDE_DEPRECATION_VERSION: null,
+  /**
+    Whether the app defaults to using async observers.
+     This is not intended to be set directly, as the implementation may change in
+    the future. Use `@ember/optional-features` instead.
+     @property _DEFAULT_ASYNC_OBSERVERS
+    @for EmberENV
+    @type Boolean
+    @default false
+    @private
+  */
+  _DEFAULT_ASYNC_OBSERVERS: false,
+  /**
+    Controls the maximum number of scheduled rerenders without "settling". In general,
+    applications should not need to modify this environment variable, but please
+    open an issue so that we can determine if a better default value is needed.
+     @property _RERENDER_LOOP_LIMIT
+    @for EmberENV
+    @type number
+    @default 1000
+    @private
+   */
+  _RERENDER_LOOP_LIMIT: 1000,
+  FEATURES: {}
+};
+const EmberENV = globalThis.EmberENV;
+if (typeof EmberENV === 'object' && EmberENV !== null) {
+  for (let flag in EmberENV) {
+    if (!Object.prototype.hasOwnProperty.call(EmberENV, flag) || flag === 'EXTEND_PROTOTYPES' || flag === 'EMBER_LOAD_HOOKS') continue;
+    let defaultValue = ENV[flag];
+    if (defaultValue === true) {
+      ENV[flag] = EmberENV[flag] !== false;
+    } else if (defaultValue === false) {
+      ENV[flag] = EmberENV[flag] === true;
+    } else {
+      ENV[flag] = EmberENV[flag];
+    }
+  }
+  let {
+    FEATURES
+  } = EmberENV;
+  if (typeof FEATURES === 'object' && FEATURES !== null) {
+    for (let feature in FEATURES) {
+      if (!Object.prototype.hasOwnProperty.call(FEATURES, feature)) continue;
+      ENV.FEATURES[feature] = FEATURES[feature] === true;
+    }
+  }
+}
+function getENV() {
+  return ENV;
+}
+
+export { ENV, context, getENV, getLookup, setLookup };

package/dist/prod/packages/@ember/-internals/error-handling/index.js

@@ -0,0 +1,26 @@
+let onerror;
+const onErrorTarget = {
+  get onerror() {
+    return onerror;
+  }
+};
+
+// Ember.onerror getter
+function getOnerror() {
+  return onerror;
+}
+// Ember.onerror setter
+function setOnerror(handler) {
+  onerror = handler;
+}
+let dispatchOverride = null;
+
+// allows testing adapter to override dispatch
+function getDispatchOverride() {
+  return dispatchOverride;
+}
+function setDispatchOverride(handler) {
+  dispatchOverride = handler;
+}
+
+export { getDispatchOverride, getOnerror, onErrorTarget, setDispatchOverride, setOnerror };

package/dist/prod/packages/@ember/-internals/glimmer/index.js

@@ -0,0 +1,39 @@
+import '../../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../../@glimmer/validator/index.js';
+import '../../../shared-chunks/reference-BNqcwZWH.js';
+export { t as template, a as templateCacheCounters } from '../../../shared-chunks/index-CSVCFS_p.js';
+import '../../../shared-chunks/capabilities-DGmQ_mz4.js';
+export { componentCapabilities, modifierCapabilities } from '../../../@glimmer/manager/index.js';
+export { C as Component, H as Helper, I as Input, L as LinkTo, O as OutletView, b as Renderer, R as RootTemplate, S as SafeString, T as Textarea, c as TrustedHTML, _ as _resetRenderers, h as helper, d as htmlSafe, i as isHTMLSafe, e as isTrustedHTML, f as renderComponent, r as renderSettled, t as trustHTML, u as uniqueId } from '../../../shared-chunks/index-DZLHQAlb.js';
+export { s as setupApplicationRegistry, a as setupEngineRegistry } from '../../../shared-chunks/setup-registry-CMNYh2jY.js';
+export { D as DOMChanges } from '../../../shared-chunks/on-CrTl7JQU.js';
+import '../../../shared-chunks/constants-b-2IVErl.js';
+export { i as isSerializationFirstNode } from '../../../shared-chunks/rehydrate-builder-CSn1aIO1.js';
+export { NodeDOMTreeConstruction } from '../../../@glimmer/node/index.js';
+export { setComponentManager } from '../../component/index.js';
+export { D as DOMTreeConstruction } from '../../../shared-chunks/element-builder-CiLTrXD6.js';
+
+// STATE within a module is frowned upon, this exists
+// to support Ember.TEMPLATES but shield ember internals from this legacy
+// global API.
+
+let TEMPLATES = {};
+function setTemplates(templates) {
+  TEMPLATES = templates;
+}
+function getTemplates() {
+  return TEMPLATES;
+}
+function getTemplate(name) {
+  if (Object.prototype.hasOwnProperty.call(TEMPLATES, name)) {
+    return TEMPLATES[name];
+  }
+}
+function hasTemplate(name) {
+  return Object.prototype.hasOwnProperty.call(TEMPLATES, name);
+}
+function setTemplate(name, template) {
+  return TEMPLATES[name] = template;
+}
+
+export { getTemplate, getTemplates, hasTemplate, setTemplate, setTemplates };

package/dist/prod/packages/@ember/-internals/meta/index.js

@@ -0,0 +1 @@
+export { Meta, UNDEFINED, counters, meta, peekMeta, setMeta } from './lib/meta.js';