ember-source 6.12.0 → 7.0.0-alpha.1

package/dist/prod/packages/shared-chunks/computed_cache-DmYKevAP.js

@@ -0,0 +1,12 @@
+import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+
+function getCachedValueFor(obj, key) {
+  let meta = peekMeta(obj);
+  if (meta) {
+    return meta.valueFor(key);
+  } else {
+    return undefined;
+  }
+}
+
+export { getCachedValueFor as g };

package/dist/prod/packages/shared-chunks/constants-b-2IVErl.js

@@ -0,0 +1,210 @@
+import { c as constants } from './fragment-EpVz5Xuc.js';
+import { e as expect } from './collections-GpG8lT2g.js';
+import { g as getInternalHelperManager, d as getInternalModifierManager, e as getInternalComponentManager } from './api-Co-k4HVs.js';
+import { e as enumerate } from './array-utils-CZQxrdD3.js';
+import '../@glimmer/validator/index.js';
+import './reference-BNqcwZWH.js';
+import { c as capabilityFlagsFrom, m as managerHasCapability } from './capabilities-DGmQ_mz4.js';
+import { g as getComponentTemplate } from './template-Dc_cBOoX.js';
+import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+import { t as templateFactory } from './index-CSVCFS_p.js';
+import { SexpOpcodes as opcodes } from '../@glimmer/wire-format/index.js';
+
+function unwrapHandle(handle) {
+  if (typeof handle === 'number') {
+    return handle;
+  } else {
+    let error = handle.errors[0];
+    throw new Error(`Compile Error: ${error.problem} @ ${error.span.start}..${error.span.end}`);
+  }
+}
+function unwrapTemplate(template) {
+  if (template.result === 'error') {
+    throw new Error(`Compile Error: ${template.problem} @ ${template.span.start}..${template.span.end}`);
+  }
+  return template;
+}
+
+/**
+ * Default component template, which is a plain yield
+ */
+const DEFAULT_TEMPLATE_BLOCK = [[[opcodes.Yield, 1, null]], ['&default'], []];
+const DEFAULT_TEMPLATE = {
+  // random uuid
+  id: '1b32f5c2-7623-43d6-a0ad-9672898920a1',
+  moduleName: '__default__.hbs',
+  block: JSON.stringify(DEFAULT_TEMPLATE_BLOCK),
+  scope: null,
+  isStrictMode: true
+};
+
+const WELL_KNOWN_EMPTY_ARRAY = Object.freeze([]);
+const STARTER_CONSTANTS = constants(WELL_KNOWN_EMPTY_ARRAY);
+const WELL_KNOWN_EMPTY_ARRAY_POSITION = STARTER_CONSTANTS.indexOf(WELL_KNOWN_EMPTY_ARRAY);
+class ConstantsImpl {
+  reifiedArrs = {
+    [WELL_KNOWN_EMPTY_ARRAY_POSITION]: WELL_KNOWN_EMPTY_ARRAY
+  };
+  defaultTemplate = templateFactory(DEFAULT_TEMPLATE)();
+
+  // Used for tests and debugging purposes, and to be able to analyze large apps
+  // This is why it's enabled even in production
+  helperDefinitionCount = 0;
+  modifierDefinitionCount = 0;
+  componentDefinitionCount = 0;
+  values = STARTER_CONSTANTS.slice();
+  indexMap = new Map(this.values.map((value, index) => [value, index]));
+  helperDefinitionCache = new WeakMap();
+  modifierDefinitionCache = new WeakMap();
+  componentDefinitionCache = new WeakMap();
+  value(value) {
+    let indexMap = this.indexMap;
+    let index = indexMap.get(value);
+    if (index === undefined) {
+      index = this.values.push(value) - 1;
+      indexMap.set(value, index);
+    }
+    return index;
+  }
+  array(values) {
+    if (values.length === 0) {
+      return WELL_KNOWN_EMPTY_ARRAY_POSITION;
+    }
+    let handles = new Array(values.length);
+    for (let i = 0; i < values.length; i++) {
+      handles[i] = this.value(values[i]);
+    }
+    return this.value(handles);
+  }
+  toPool() {
+    return this.values;
+  }
+  hasHandle(handle) {
+    return this.values.length > handle;
+  }
+  helper(definitionState,
+  // TODO: Add a way to expose resolved name for debugging
+  _resolvedName = null, isOptional) {
+    let handle = this.helperDefinitionCache.get(definitionState);
+    if (handle === undefined) {
+      let managerOrHelper = getInternalHelperManager(definitionState, isOptional);
+      if (managerOrHelper === null) {
+        this.helperDefinitionCache.set(definitionState, null);
+        return null;
+      }
+      let helper = typeof managerOrHelper === 'function' ? managerOrHelper : managerOrHelper.getHelper(definitionState);
+      handle = this.value(helper);
+      this.helperDefinitionCache.set(definitionState, handle);
+      this.helperDefinitionCount++;
+    }
+    return handle;
+  }
+  modifier(definitionState, resolvedName = null, isOptional) {
+    let handle = this.modifierDefinitionCache.get(definitionState);
+    if (handle === undefined) {
+      let manager = getInternalModifierManager(definitionState);
+      if (manager === null) {
+        this.modifierDefinitionCache.set(definitionState, null);
+        return null;
+      }
+      let definition = {
+        resolvedName,
+        manager,
+        state: definitionState
+      };
+      handle = this.value(definition);
+      this.modifierDefinitionCache.set(definitionState, handle);
+      this.modifierDefinitionCount++;
+    }
+    return handle;
+  }
+  component(definitionState, owner, isOptional, debugName) {
+    let definition = this.componentDefinitionCache.get(definitionState);
+    if (definition === undefined) {
+      let manager = getInternalComponentManager(definitionState);
+      if (manager === null) {
+        this.componentDefinitionCache.set(definitionState, null);
+        return null;
+      }
+      let capabilities = capabilityFlagsFrom(manager.getCapabilities(definitionState));
+      let templateFactory = getComponentTemplate(definitionState);
+      let compilable = null;
+      let template;
+      if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout)) {
+        template = templateFactory?.(owner) ?? this.defaultTemplate;
+      } else {
+        template = templateFactory?.(owner);
+      }
+      if (template !== undefined) {
+        template = unwrapTemplate(template);
+        compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout();
+      }
+      definition = {
+        resolvedName: null,
+        handle: -1,
+        // replaced momentarily
+        manager,
+        capabilities,
+        state: definitionState,
+        compilable
+      };
+      definition.handle = this.value(definition);
+      if (debugName) {
+        definition.debugName = debugName;
+      }
+      this.componentDefinitionCache.set(definitionState, definition);
+      this.componentDefinitionCount++;
+    }
+    return definition;
+  }
+  resolvedComponent(resolvedDefinition, resolvedName) {
+    let definition = this.componentDefinitionCache.get(resolvedDefinition);
+    if (definition === undefined) {
+      let {
+        manager,
+        state,
+        template
+      } = resolvedDefinition;
+      let capabilities = capabilityFlagsFrom(manager.getCapabilities(resolvedDefinition));
+      let compilable = null;
+      if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout)) {
+        template = template ?? this.defaultTemplate;
+      }
+      if (template !== null) {
+        template = unwrapTemplate(template);
+        compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout();
+      }
+      definition = {
+        resolvedName,
+        handle: -1,
+        // replaced momentarily
+        manager,
+        capabilities,
+        state,
+        compilable
+      };
+      definition.handle = this.value(definition);
+      this.componentDefinitionCache.set(resolvedDefinition, definition);
+      this.componentDefinitionCount++;
+    }
+    return expect(definition);
+  }
+  getValue(index) {
+    return this.values[index];
+  }
+  getArray(index) {
+    let reifiedArrs = this.reifiedArrs;
+    let reified = reifiedArrs[index];
+    if (reified === undefined) {
+      let names = this.getValue(index);
+      reified = new Array(names.length);
+      for (const [i, name] of enumerate(names)) {
+        reified[i] = this.getValue(name);
+      }
+      reifiedArrs[index] = reified;
+    }
+    return reified;
+  }
+}
+
+export { ConstantsImpl as C, unwrapTemplate as a, unwrapHandle as u };

package/dist/prod/packages/shared-chunks/debug-brand-B1TWjOCH.js

@@ -0,0 +1,12 @@
+/**
+ * An object branded with a local debug type has special local trace logging
+ * behavior.
+ *
+ * If `LOCAL_DEBUG` is `false`, this function does nothing (and is removed
+ * by the minifier in builder).
+ */
+
+function setLocalDebugType(type, ...brand) {
+}
+
+export { setLocalDebugType as s };

package/dist/prod/packages/shared-chunks/decorator-BdDDBUd2.js

@@ -0,0 +1,123 @@
+import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import '../@ember/-internals/environment/index.js';
+
+// Same as built-in MethodDecorator but with more arguments
+
+function isElementDescriptor(args) {
+  let [maybeTarget, maybeKey, maybeDesc] = args;
+  return (
+    // Ensure we have the right number of args
+    args.length === 3 && (
+    // Make sure the target is a class or object (prototype)
+    typeof maybeTarget === 'function' || typeof maybeTarget === 'object' && maybeTarget !== null) &&
+    // Make sure the key is a string
+    typeof maybeKey === 'string' && (
+    // Make sure the descriptor is the right shape
+    typeof maybeDesc === 'object' && maybeDesc !== null || maybeDesc === undefined)
+  );
+}
+function nativeDescDecorator(propertyDesc) {
+  let decorator = function () {
+    return propertyDesc;
+  };
+  setClassicDecorator(decorator);
+  return decorator;
+}
+
+/**
+  Objects of this type can implement an interface to respond to requests to
+  get and set. The default implementation handles simple properties.
+
+  @class Descriptor
+  @private
+*/
+class ComputedDescriptor {
+  enumerable = true;
+  configurable = true;
+  _dependentKeys = undefined;
+  _meta = undefined;
+  setup(_obj, keyName, _propertyDesc, meta) {
+    meta.writeDescriptors(keyName, this);
+  }
+  teardown(_obj, keyName, meta) {
+    meta.removeDescriptors(keyName);
+  }
+}
+function DESCRIPTOR_GETTER_FUNCTION(name, descriptor) {
+  function getter() {
+    return descriptor.get(this, name);
+  }
+  return getter;
+}
+function DESCRIPTOR_SETTER_FUNCTION(name, descriptor) {
+  let set = function CPSETTER_FUNCTION(value) {
+    return descriptor.set(this, name, value);
+  };
+  COMPUTED_SETTERS.add(set);
+  return set;
+}
+const COMPUTED_SETTERS = new WeakSet();
+function makeComputedDecorator(desc, DecoratorClass) {
+  let decorator = function COMPUTED_DECORATOR(target, key, propertyDesc, maybeMeta, isClassicDecorator) {
+    let meta$1 = arguments.length === 3 ? meta(target) : maybeMeta;
+    desc.setup(target, key, propertyDesc, meta$1);
+    let computedDesc = {
+      enumerable: desc.enumerable,
+      configurable: desc.configurable,
+      get: DESCRIPTOR_GETTER_FUNCTION(key, desc),
+      set: DESCRIPTOR_SETTER_FUNCTION(key, desc)
+    };
+    return computedDesc;
+  };
+  setClassicDecorator(decorator, desc);
+  Object.setPrototypeOf(decorator, DecoratorClass.prototype);
+  return decorator;
+}
+
+/////////////
+
+const DECORATOR_DESCRIPTOR_MAP = new WeakMap();
+
+/**
+  Returns the CP descriptor associated with `obj` and `keyName`, if any.
+
+  @method descriptorForProperty
+  @param {Object} obj the object to check
+  @param {String} keyName the key to check
+  @return {Descriptor}
+  @private
+*/
+function descriptorForProperty(obj, keyName, _meta) {
+  let meta = _meta === undefined ? peekMeta(obj) : _meta;
+  if (meta !== null) {
+    return meta.peekDescriptors(keyName);
+  }
+}
+function descriptorForDecorator(dec) {
+  return DECORATOR_DESCRIPTOR_MAP.get(dec);
+}
+
+/**
+  Check whether a value is a decorator
+
+  @method isClassicDecorator
+  @param {any} possibleDesc the value to check
+  @return {boolean}
+  @private
+*/
+function isClassicDecorator(dec) {
+  return typeof dec === 'function' && DECORATOR_DESCRIPTOR_MAP.has(dec);
+}
+
+/**
+  Set a value as a decorator
+
+  @method setClassicDecorator
+  @param {function} decorator the value to mark as a decorator
+  @private
+*/
+function setClassicDecorator(dec, value = true) {
+  DECORATOR_DESCRIPTOR_MAP.set(dec, value);
+}
+
+export { COMPUTED_SETTERS as C, isClassicDecorator as a, descriptorForDecorator as b, ComputedDescriptor as c, descriptorForProperty as d, isElementDescriptor as i, makeComputedDecorator as m, nativeDescDecorator as n, setClassicDecorator as s };

package/dist/prod/packages/shared-chunks/dictionary-gc5gpyOG.js

@@ -0,0 +1,13 @@
+// the delete is meant to hint at runtimes that this object should remain in
+// dictionary mode. This is clearly a runtime specific hack, but currently it
+// appears worthwhile in some usecases. Please note, these deletes do increase
+// the cost of creation dramatically over a plain Object.create. And as this
+// only makes sense for long-lived dictionaries that aren't instantiated often.
+function makeDictionary(parent) {
+  let dict = Object.create(parent);
+  dict['_dict'] = null;
+  delete dict['_dict'];
+  return dict;
+}
+
+export { makeDictionary as m };