ember-source 7.1.0-alpha.4 → 7.1.0-beta.1

package/dist/dev/packages/shared-chunks/decorator-B5Uh5NFI.js

@@ -0,0 +1,135 @@
+import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import '../@ember/debug/index.js';
+import { assert } from '../@ember/debug/lib/assert.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);
+  }
+}
+let COMPUTED_GETTERS;
+{
+  COMPUTED_GETTERS = new WeakSet();
+}
+function DESCRIPTOR_GETTER_FUNCTION(name, descriptor) {
+  function getter() {
+    return descriptor.get(this, name);
+  }
+  {
+    COMPUTED_GETTERS.add(getter);
+  }
+  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) {
+    (!(isClassicDecorator || !propertyDesc || !propertyDesc.get || !COMPUTED_GETTERS.has(propertyDesc.get)) && assert(`Only one computed property decorator can be applied to a class field or accessor, but '${key}' was decorated twice. You may have added the decorator to both a getter and setter, which is unnecessary.`, isClassicDecorator || !propertyDesc || !propertyDesc.get || !COMPUTED_GETTERS.has(propertyDesc.get)));
+    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) {
+  (!(obj !== null) && assert('Cannot call `descriptorForProperty` on null', obj !== null));
+  (!(obj !== undefined) && assert('Cannot call `descriptorForProperty` on undefined', obj !== undefined));
+  (!(typeof obj === 'object' || typeof obj === 'function') && assert(`Cannot call \`descriptorForProperty\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function'));
+  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/dev/packages/shared-chunks/element-DQJOvSlQ.js

@@ -0,0 +1,109 @@
+import { a as createComputeRef, v as valueForRef, N as NULL_REFERENCE } from './reference-BoPB2LfI.js';
+import { s as setInternalComponentManager } from './api-BawZUDYD.js';
+import '../@ember/debug/index.js';
+import { i as internalHelper } from './internal-helper-Ez7zbEIa.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+/**
+  @module @ember/helper
+*/
+
+
+// ============ Element Component (for string tag names) ============
+// Renders content wrapped in the specified HTML element, or just renders
+// content without a wrapper for empty string.
+
+const ELEMENT_CAPABILITIES = {
+  createInstance: true,
+  wrapped: true
+};
+class ElementComponentManager {
+  getCapabilities() {
+    return ELEMENT_CAPABILITIES;
+  }
+  getDebugName(state) {
+    return `(element "${state.tagName}")`;
+  }
+  getSelf() {
+    return NULL_REFERENCE;
+  }
+  getDestroyable() {
+    return null;
+  }
+  didCreateElement() {}
+  create(_owner, state) {
+    // For empty string, return null so getTagName returns null (no wrapper element)
+    return state.tagName || null;
+  }
+  getTagName(state) {
+    return state;
+  }
+  didRenderLayout() {}
+  didUpdateLayout() {}
+  didCreate() {}
+  didUpdate() {}
+}
+const ELEMENT_COMPONENT_MANAGER = new ElementComponentManager();
+class ElementComponentDefinition {
+  constructor(tagName) {
+    this.tagName = tagName;
+  }
+  toString() {
+    return `(element "${this.tagName}")`;
+  }
+}
+setInternalComponentManager(ELEMENT_COMPONENT_MANAGER, ElementComponentDefinition.prototype);
+
+// Cache component definitions per tag name to avoid creating duplicate definitions
+const ELEMENT_DEFINITIONS = new Map();
+function getElementDefinition(tagName) {
+  let definition = ELEMENT_DEFINITIONS.get(tagName);
+  if (definition === undefined) {
+    definition = new ElementComponentDefinition(tagName);
+    ELEMENT_DEFINITIONS.set(tagName, definition);
+  }
+  return definition;
+}
+
+// ============ Element Helper ============
+
+/**
+  The `element` helper lets you dynamically set the tag name of an element.
+
+  ```handlebars
+  {{#let (element @tagName) as |Tag|}}
+    <Tag class="my-element">Hello</Tag>
+  {{/let}}
+  ```
+
+  When `@tagName` is `"h1"`, this renders `<h1 class="my-element">Hello</h1>`.
+
+  When `@tagName` is an empty string `""`, the block content is rendered without
+  a wrapping element.
+
+  Passing `null`, `undefined`, or non-string values will throw an assertion error.
+
+  Changing the tag name will tear down and recreate the element and its contents.
+
+  @method element
+  @for Ember.Templates.helpers
+  @public
+*/
+const element = internalHelper(({
+  positional,
+  named
+}) => {
+  return createComputeRef(() => {
+    {
+      (!(positional.length === 1) && assert('The `element` helper takes a single positional argument', positional.length === 1));
+      (!(Object.keys(named).length === 0) && assert('The `element` helper does not take any named arguments', Object.keys(named).length === 0));
+    }
+    let tagName = valueForRef(positional[0]);
+    {
+      (!(typeof tagName === 'string') && assert(`The argument passed to the \`element\` helper must be a string${tagName === null || tagName === undefined || typeof tagName === 'object' ? '' : ` (you passed \`${tagName}\`)`}`, typeof tagName === 'string'));
+    }
+    return getElementDefinition(tagName);
+  }, null, 'element');
+});
+
+export { element as e };