ember-source 6.12.0 → 7.0.0-alpha.1

package/dist/prod/packages/@ember/-internals/views/lib/system/utils.js

@@ -0,0 +1,172 @@
+import { getOwner } from '../../../owner/index.js';
+import { g as guidFor } from '../../../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../environment/index.js';
+
+/**
+@module ember
+*/
+
+function isSimpleClick(event) {
+  if (!(event instanceof MouseEvent)) {
+    return false;
+  }
+  let modifier = event.shiftKey || event.metaKey || event.altKey || event.ctrlKey;
+  let secondaryClick = event.button !== 0;
+  return !modifier && !secondaryClick;
+}
+function constructStyleDeprecationMessage(affectedStyle) {
+  return '' + 'Binding style attributes may introduce cross-site scripting vulnerabilities; ' + 'please ensure that values being bound are properly escaped. For more information, ' + 'including how to disable this warning, see ' + 'https://deprecations.emberjs.com/v1.x/#toc_binding-style-attributes. ' + 'Style affected: "' + affectedStyle + '"';
+}
+
+/**
+  @private
+  @method getRootViews
+  @param {Object} owner
+*/
+function getRootViews(owner) {
+  let registry = owner.lookup('-view-registry:main');
+  let rootViews = [];
+  Object.keys(registry).forEach(id => {
+    let view = registry[id];
+    if (view.parentView === null) {
+      rootViews.push(view);
+    }
+  });
+  return rootViews;
+}
+
+/**
+  @private
+  @method getViewId
+  @param {Ember.View} view
+ */
+function getViewId(view) {
+  if (view.tagName !== '' && view.elementId) {
+    return view.elementId;
+  } else {
+    return guidFor(view);
+  }
+}
+const ELEMENT_VIEW = new WeakMap();
+const VIEW_ELEMENT = new WeakMap();
+function getElementView(element) {
+  return ELEMENT_VIEW.get(element) || null;
+}
+
+/**
+  @private
+  @method getViewElement
+  @param {Ember.View} view
+ */
+function getViewElement(view) {
+  return VIEW_ELEMENT.get(view) || null;
+}
+function setElementView(element, view) {
+  ELEMENT_VIEW.set(element, view);
+}
+function setViewElement(view, element) {
+  VIEW_ELEMENT.set(view, element);
+}
+
+// These are not needed for GC, but for correctness. We want to be able to
+// null-out these links while the objects are still live. Specifically, in
+// this case, we want to prevent access to the element (and vice verse) during
+// destruction.
+
+function clearElementView(element) {
+  ELEMENT_VIEW.delete(element);
+}
+function clearViewElement(view) {
+  VIEW_ELEMENT.delete(view);
+}
+const CHILD_VIEW_IDS = new WeakMap();
+
+/**
+  @private
+  @method getChildViews
+  @param {Ember.View} view
+*/
+function getChildViews(view) {
+  let owner = getOwner(view);
+  let registry = owner.lookup('-view-registry:main');
+  return collectChildViews(view, registry);
+}
+function initChildViews(view) {
+  let childViews = new Set();
+  CHILD_VIEW_IDS.set(view, childViews);
+  return childViews;
+}
+function addChildView(parent, child) {
+  let childViews = CHILD_VIEW_IDS.get(parent);
+  if (childViews === undefined) {
+    childViews = initChildViews(parent);
+  }
+  childViews.add(getViewId(child));
+}
+function collectChildViews(view, registry) {
+  let views = [];
+  let childViews = CHILD_VIEW_IDS.get(view);
+  if (childViews !== undefined) {
+    childViews.forEach(id => {
+      let view = registry[id];
+      if (view && !view.isDestroying && !view.isDestroyed) {
+        views.push(view);
+      }
+    });
+  }
+  return views;
+}
+
+/**
+  @private
+  @method getViewBounds
+  @param {Ember.View} view
+*/
+function getViewBounds(view) {
+  return view.renderer.getBounds(view);
+}
+
+/**
+  @private
+  @method getViewRange
+  @param {Ember.View} view
+*/
+function getViewRange(view) {
+  let bounds = getViewBounds(view);
+  let range = document.createRange();
+  range.setStartBefore(bounds.firstNode);
+  range.setEndAfter(bounds.lastNode);
+  return range;
+}
+
+/**
+  `getViewClientRects` provides information about the position of the border
+  box edges of a view relative to the viewport.
+
+  It is only intended to be used by development tools like the Ember Inspector.
+
+  @private
+  @method getViewClientRects
+  @param {Ember.View} view
+*/
+function getViewClientRects(view) {
+  let range = getViewRange(view);
+  return range.getClientRects();
+}
+
+/**
+  `getViewBoundingClientRect` provides information about the position of the
+  bounding border box edges of a view relative to the viewport.
+
+  It is only intended to be used by development tools like the Ember Inspector.
+
+  @private
+  @method getViewBoundingClientRect
+  @param {Ember.View} view
+*/
+function getViewBoundingClientRect(view) {
+  let range = getViewRange(view);
+  return range.getBoundingClientRect();
+}
+
+export { addChildView, clearElementView, clearViewElement, constructStyleDeprecationMessage, getChildViews, getElementView, getRootViews, getViewBoundingClientRect, getViewBounds, getViewClientRects, getViewElement, getViewId, isSimpleClick, setElementView, setViewElement };

package/dist/prod/packages/@ember/-internals/views/lib/views/core_view.js

@@ -0,0 +1,87 @@
+import '../../../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../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 } from '../../../../../shared-chunks/injected_property-DL3vQoFA.js';
+import '../../../runtime/lib/mixins/registry_proxy.js';
+import '../../../runtime/lib/mixins/container_proxy.js';
+import '../../../runtime/lib/mixins/comparable.js';
+import ActionHandler from '../../../runtime/lib/mixins/action_handler.js';
+import '../../../runtime/lib/mixins/-proxy.js';
+import '../../../../enumerable/mutable.js';
+import '../../../runtime/lib/mixins/target_action_support.js';
+import '../../../runtime/lib/ext/rsvp.js';
+import Evented from '../../../../object/evented.js';
+import { FrameworkObject } from '../../../../object/-internals.js';
+import states from './states.js';
+import { d as decorateFieldV2, i as initializeDeferredDecorator } from '../../../../../shared-chunks/chunk-3SQBS3Y5-Cj4eryg1.js';
+
+class CoreView extends FrameworkObject.extend(Evented, ActionHandler) {
+  isView = true;
+  _superTrigger;
+  _superHas;
+
+  /**
+    If the view is currently inserted into the DOM of a parent view, this
+    property will point to the parent of the view.
+     @property parentView
+    @type Ember.View
+    @default null
+    @private
+  */
+
+  init(properties) {
+    super.init(properties);
+
+    // Handle methods from Evented
+    // The native class inheritance will not work for mixins. To work around this,
+    // we copy the existing trigger and has methods provided by the mixin and swap in the
+    // new ones from our class.
+    this._superTrigger = this.trigger;
+    this.trigger = this._trigger;
+    this._superHas = this.has;
+    this.has = this._has;
+    this.parentView ??= null;
+    this._state = 'preRender';
+    this._currentState = this._states.preRender;
+  }
+  static {
+    decorateFieldV2(this.prototype, "renderer", [inject('renderer', '-dom')]);
+  }
+  #renderer = (initializeDeferredDecorator(this, "renderer"), void 0);
+  instrumentDetails(hash) {
+    hash['object'] = this.toString();
+    hash['containerKey'] = this._debugContainerKey;
+    hash['view'] = this;
+    return hash;
+  }
+
+  /**
+    Override the default event firing from `Evented` to
+    also call methods with the given name.
+     @method trigger
+    @param name {String}
+    @private
+  */
+  // Changed to `trigger` on init
+  _trigger(name, ...args) {
+    this._superTrigger(name, ...args);
+    let method = this[name];
+    if (typeof method === 'function') {
+      return method.apply(this, args);
+    }
+  }
+
+  // Changed to `has` on init
+  _has(name) {
+    return typeof this[name] === 'function' || this._superHas(name);
+  }
+  static isViewFactory = true;
+}
+
+// Declare on the prototype to have a single shared value.
+CoreView.prototype._states = states;
+
+export { CoreView as default };

package/dist/prod/packages/@ember/-internals/views/lib/views/states.js

@@ -0,0 +1,83 @@
+import '../../../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../environment/index.js';
+import { flaggedInstrument } from '../../../../instrumentation/index.js';
+import { join } from '../../../../runloop/index.js';
+
+const DEFAULT = Object.freeze({
+  // appendChild is only legal while rendering the buffer.
+  appendChild() {
+    throw new Error("You can't use appendChild outside of the rendering process");
+  },
+  // Handle events from `Ember.EventDispatcher`
+  handleEvent() {
+    return true; // continue event propagation
+  },
+  rerender() {},
+  destroy() {}
+});
+const PRE_RENDER = Object.freeze({
+  ...DEFAULT
+});
+const HAS_ELEMENT = Object.freeze({
+  ...DEFAULT,
+  rerender(view) {
+    view.renderer.rerender();
+  },
+  destroy(view) {
+    view.renderer.remove(view);
+  },
+  // Handle events from `Ember.EventDispatcher`
+  handleEvent(view, eventName, event) {
+    if (view.has(eventName)) {
+      // Handler should be able to re-dispatch events, so we don't
+      // preventDefault or stopPropagation.
+      return flaggedInstrument(`interaction.${eventName}`, {
+        }, () => {
+        return join(view, view.trigger, eventName, event);
+      });
+    } else {
+      return true; // continue event propagation
+    }
+  }
+});
+const IN_DOM = Object.freeze({
+  ...HAS_ELEMENT,
+  enter(view) {
+    // Register the view for event handling. This hash is used by
+    // Ember.EventDispatcher to dispatch incoming events.
+    view.renderer.register(view);
+  }
+});
+const DESTROYING = Object.freeze({
+  ...DEFAULT,
+  appendChild() {
+    throw new Error("You can't call appendChild on a view being destroyed");
+  },
+  rerender() {
+    throw new Error("You can't call rerender on a view being destroyed");
+  }
+});
+
+/*
+  Describe how the specified actions should behave in the various
+  states that a view can exist in. Possible states:
+
+  * preRender: when a view is first instantiated, and after its
+    element was destroyed, it is in the preRender state
+  * hasElement: the DOM representation of the view is created,
+    and is ready to be inserted
+  * inDOM: once a view has been inserted into the DOM it is in
+    the inDOM state. A view spends the vast majority of its
+    existence in this state.
+  * destroyed: once a view has been destroyed (using the destroy
+    method), it is in this state. No further actions can be invoked
+    on a destroyed view.
+*/
+const states = Object.freeze({
+  preRender: PRE_RENDER,
+  inDOM: IN_DOM,
+  hasElement: HAS_ELEMENT,
+  destroying: DESTROYING
+});
+
+export { states as default };