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

package/dist/prod/packages/shared-chunks/observers-CDkeR0nI.js

@@ -0,0 +1,199 @@
+import { E as ENV } from './env-DXxsTFkM.js';
+import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import { registerDestructor } from '../@glimmer/destroyable/index.js';
+import { d as valueForTag, v as validateTag, i as CURRENT_TAG } from './cache-BIlOoPA7.js';
+import { a as tagMetaFor } from './meta-B9mldqPL.js';
+import { g as getChainTagsForKey } from './chain-tags-C9rFtQ_x.js';
+import { a as addListener, r as removeListener, s as sendEvent } from './events-DYrYz3V8.js';
+
+const AFTER_OBSERVERS = ':change';
+function changeEvent(keyName) {
+  return keyName + AFTER_OBSERVERS;
+}
+
+const SYNC_DEFAULT = !ENV._DEFAULT_ASYNC_OBSERVERS;
+const SYNC_OBSERVERS = new Map();
+const ASYNC_OBSERVERS = new Map();
+
+/**
+@module @ember/object
+*/
+
+/**
+  @method addObserver
+  @static
+  @for @ember/object/observers
+  @param obj
+  @param {String} path
+  @param {Object|Function} target
+  @param {Function|String} [method]
+  @public
+*/
+function addObserver(obj, path, target, method, sync = SYNC_DEFAULT) {
+  let eventName = changeEvent(path);
+  addListener(obj, eventName, target, method, false, sync);
+  let meta = peekMeta(obj);
+  if (meta === null || !(meta.isPrototypeMeta(obj) || meta.isInitializing())) {
+    activateObserver(obj, eventName, sync);
+  }
+}
+
+/**
+  @method removeObserver
+  @static
+  @for @ember/object/observers
+  @param obj
+  @param {String} path
+  @param {Object|Function} target
+  @param {Function|String} [method]
+  @public
+*/
+function removeObserver(obj, path, target, method, sync = SYNC_DEFAULT) {
+  let eventName = changeEvent(path);
+  let meta = peekMeta(obj);
+  if (meta === null || !(meta.isPrototypeMeta(obj) || meta.isInitializing())) {
+    deactivateObserver(obj, eventName, sync);
+  }
+  removeListener(obj, eventName, target, method);
+}
+function getOrCreateActiveObserversFor(target, sync) {
+  let observerMap = sync === true ? SYNC_OBSERVERS : ASYNC_OBSERVERS;
+  if (!observerMap.has(target)) {
+    observerMap.set(target, new Map());
+    registerDestructor(target, () => destroyObservers(target), true);
+  }
+  return observerMap.get(target);
+}
+function activateObserver(target, eventName, sync = false) {
+  let activeObservers = getOrCreateActiveObserversFor(target, sync);
+  if (activeObservers.has(eventName)) {
+    activeObservers.get(eventName).count++;
+  } else {
+    let path = eventName.substring(0, eventName.lastIndexOf(':'));
+    let tag = getChainTagsForKey(target, path, tagMetaFor(target), peekMeta(target));
+    activeObservers.set(eventName, {
+      count: 1,
+      path,
+      tag,
+      lastRevision: valueForTag(tag),
+      suspended: false
+    });
+  }
+}
+let DEACTIVATE_SUSPENDED = false;
+let SCHEDULED_DEACTIVATE = [];
+function deactivateObserver(target, eventName, sync = false) {
+  if (DEACTIVATE_SUSPENDED === true) {
+    SCHEDULED_DEACTIVATE.push([target, eventName, sync]);
+    return;
+  }
+  let observerMap = sync === true ? SYNC_OBSERVERS : ASYNC_OBSERVERS;
+  let activeObservers = observerMap.get(target);
+  if (activeObservers !== undefined) {
+    let observer = activeObservers.get(eventName);
+    observer.count--;
+    if (observer.count === 0) {
+      activeObservers.delete(eventName);
+      if (activeObservers.size === 0) {
+        observerMap.delete(target);
+      }
+    }
+  }
+}
+function suspendedObserverDeactivation() {
+  DEACTIVATE_SUSPENDED = true;
+}
+function resumeObserverDeactivation() {
+  DEACTIVATE_SUSPENDED = false;
+  for (let [target, eventName, sync] of SCHEDULED_DEACTIVATE) {
+    deactivateObserver(target, eventName, sync);
+  }
+  SCHEDULED_DEACTIVATE = [];
+}
+
+/**
+ * Primarily used for cases where we are redefining a class, e.g. mixins/reopen
+ * being applied later. Revalidates all the observers, resetting their tags.
+ *
+ * @private
+ * @param target
+ */
+function revalidateObservers(target) {
+  if (ASYNC_OBSERVERS.has(target)) {
+    ASYNC_OBSERVERS.get(target).forEach(observer => {
+      observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+      observer.lastRevision = valueForTag(observer.tag);
+    });
+  }
+  if (SYNC_OBSERVERS.has(target)) {
+    SYNC_OBSERVERS.get(target).forEach(observer => {
+      observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+      observer.lastRevision = valueForTag(observer.tag);
+    });
+  }
+}
+let lastKnownRevision = 0;
+function flushAsyncObservers(_schedule) {
+  let currentRevision = valueForTag(CURRENT_TAG);
+  if (lastKnownRevision === currentRevision) {
+    return;
+  }
+  lastKnownRevision = currentRevision;
+  ASYNC_OBSERVERS.forEach((activeObservers, target) => {
+    let meta = peekMeta(target);
+    activeObservers.forEach((observer, eventName) => {
+      if (!validateTag(observer.tag, observer.lastRevision)) {
+        let sendObserver = () => {
+          try {
+            sendEvent(target, eventName, [target, observer.path], undefined, meta);
+          } finally {
+            observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+            observer.lastRevision = valueForTag(observer.tag);
+          }
+        };
+        if (_schedule) {
+          _schedule('actions', sendObserver);
+        } else {
+          sendObserver();
+        }
+      }
+    });
+  });
+}
+function flushSyncObservers() {
+  // When flushing synchronous observers, we know that something has changed (we
+  // only do this during a notifyPropertyChange), so there's no reason to check
+  // a global revision.
+
+  SYNC_OBSERVERS.forEach((activeObservers, target) => {
+    let meta = peekMeta(target);
+    activeObservers.forEach((observer, eventName) => {
+      if (!observer.suspended && !validateTag(observer.tag, observer.lastRevision)) {
+        try {
+          observer.suspended = true;
+          sendEvent(target, eventName, [target, observer.path], undefined, meta);
+        } finally {
+          observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+          observer.lastRevision = valueForTag(observer.tag);
+          observer.suspended = false;
+        }
+      }
+    });
+  });
+}
+function setObserverSuspended(target, property, suspended) {
+  let activeObservers = SYNC_OBSERVERS.get(target);
+  if (!activeObservers) {
+    return;
+  }
+  let observer = activeObservers.get(changeEvent(property));
+  if (observer) {
+    observer.suspended = suspended;
+  }
+}
+function destroyObservers(target) {
+  if (SYNC_OBSERVERS.size > 0) SYNC_OBSERVERS.delete(target);
+  if (ASYNC_OBSERVERS.size > 0) ASYNC_OBSERVERS.delete(target);
+}
+
+export { ASYNC_OBSERVERS as A, SYNC_OBSERVERS as S, activateObserver as a, addObserver as b, revalidateObservers as c, flushSyncObservers as d, resumeObserverDeactivation as e, flushAsyncObservers as f, setObserverSuspended as g, removeObserver as r, suspendedObserverDeactivation as s };

package/dist/prod/packages/shared-chunks/on-B5NVufs_.js

@@ -0,0 +1,228 @@
+import { g as check } from './debug-render-tree-CF5O4-WI.js';
+import { registerDestructor } from '../@glimmer/destroyable/index.js';
+import { k as setInternalModifierManager } from './api-zh_k31vb.js';
+import { v as valueForRef } from './reference-BshxG6wn.js';
+import { c as createUpdatableTag } from './cache-BIlOoPA7.js';
+
+class OnModifierState {
+  tag = createUpdatableTag();
+  element;
+  args;
+  listener = null;
+  constructor(element, args) {
+    this.element = element;
+    this.args = args;
+    registerDestructor(this, () => {
+      let {
+        element,
+        listener
+      } = this;
+      if (listener) {
+        let {
+          eventName,
+          callback,
+          options
+        } = listener;
+        removeEventListener(element, eventName, callback, options);
+      }
+    });
+  }
+
+  // Update this.listener if needed
+  updateListener() {
+    let {
+      element,
+      args,
+      listener
+    } = this;
+    let arg0 = args.positional[0];
+    let eventName = check(arg0 ? valueForRef(arg0) : undefined);
+    let arg1 = args.positional[1];
+    let userProvidedCallback = check(arg1 ? valueForRef(arg1) : undefined);
+    let once = undefined;
+    let passive = undefined;
+    let capture = undefined;
+    {
+      let {
+        once: _once,
+        passive: _passive,
+        capture: _capture
+      } = args.named;
+      if (_once) {
+        once = valueForRef(_once);
+      }
+      if (_passive) {
+        passive = valueForRef(_passive);
+      }
+      if (_capture) {
+        capture = valueForRef(_capture);
+      }
+    }
+    let shouldUpdate = false;
+    if (listener === null) {
+      shouldUpdate = true;
+    } else {
+      shouldUpdate = eventName !== listener.eventName || userProvidedCallback !== listener.userProvidedCallback || once !== listener.once || passive !== listener.passive || capture !== listener.capture;
+    }
+    let options = undefined;
+
+    // we want to handle both `true` and `false` because both have a meaning:
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=770208
+    if (shouldUpdate) {
+      if (once !== undefined || passive !== undefined || capture !== undefined) {
+        options = {
+          once,
+          passive,
+          capture
+        };
+      }
+    }
+    if (shouldUpdate) {
+      let callback = userProvidedCallback;
+      this.listener = {
+        eventName,
+        callback,
+        userProvidedCallback,
+        once,
+        passive,
+        capture,
+        options
+      };
+      if (listener) {
+        removeEventListener(element, listener.eventName, listener.callback, listener.options);
+      }
+      addEventListener(element, eventName, callback, options);
+    }
+  }
+}
+let adds = 0;
+let removes = 0;
+function removeEventListener(element, eventName, callback, options) {
+  removes++;
+  element.removeEventListener(eventName, callback, options);
+}
+function addEventListener(element, eventName, callback, options) {
+  adds++;
+  element.addEventListener(eventName, callback, options);
+}
+
+/**
+  The `{{on}}` modifier lets you easily add event listeners (it uses
+  [EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
+  internally).
+
+  For example, if you'd like to run a function on your component when a `<button>`
+  in the components template is clicked you might do something like:
+
+  ```app/components/like-post.hbs
+  <button {{on 'click' this.saveLike}}>Like this post!</button>
+  ```
+
+  ```app/components/like-post.js
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+
+  export default class LikePostComponent extends Component {
+    saveLike = () => {
+      // someone likes your post!
+      // better send a request off to your server...
+    }
+  }
+  ```
+
+  ### Arguments
+
+  `{{on}}` accepts two positional arguments, and a few named arguments.
+
+  The positional arguments are:
+
+  - `event` -- the name to use when calling `addEventListener`
+  - `callback` -- the function to be passed to `addEventListener`
+
+  The named arguments are:
+
+  - capture -- a `true` value indicates that events of this type will be dispatched
+    to the registered listener before being dispatched to any EventTarget beneath it
+    in the DOM tree.
+  - once -- indicates that the listener should be invoked at most once after being
+    added. If true, the listener would be automatically removed when invoked.
+  - passive -- if `true`, indicates that the function specified by listener will never
+    call preventDefault(). If a passive listener does call preventDefault(), the user
+    agent will do nothing other than generate a console warning. See
+    [Improving scrolling performance with passive listeners](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Improving_scrolling_performance_with_passive_listeners)
+    to learn more.
+
+  The callback function passed to `{{on}}` will receive any arguments that are passed
+  to the event handler. Most commonly this would be the `event` itself.
+
+  If you would like to pass additional arguments to the function you should use
+  the `{{fn}}` helper.
+
+  For example, in our example case above if you'd like to pass in the post that
+  was being liked when the button is clicked you could do something like:
+
+  ```app/components/like-post.hbs
+  <button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>
+  ```
+
+  In this case, the `saveLike` function will receive two arguments: the click event
+  and the value of `@post`.
+
+  ### Function Context
+
+  In the example above, we used an arrow function to ensure that `likePost` is
+  properly bound to the `items-list`, but let's explore what happens if we
+  left out the arrow function:
+
+  ```app/components/like-post.js
+  import Component from '@glimmer/component';
+
+  export default class LikePostComponent extends Component {
+    saveLike() {
+      // ...snip...
+    }
+  }
+  ```
+
+  In this example, when the button is clicked `saveLike` will be invoked,
+  it will **not** have access to the component instance. In other
+  words, it will have no `this` context, so please make sure your functions
+  are bound (via an arrow function or other means) before passing into `on`!
+
+  @method on
+  @public
+*/
+class OnModifierManager {
+  getDebugName() {
+    return 'on';
+  }
+  getDebugInstance() {
+    return null;
+  }
+  get counters() {
+    return {
+      adds,
+      removes
+    };
+  }
+  create(_owner, element, _state, args) {
+    return new OnModifierState(element, args);
+  }
+  getTag({
+    tag
+  }) {
+    return tag;
+  }
+  install(state) {
+    state.updateListener();
+  }
+  update(state) {
+    state.updateListener();
+  }
+  getDestroyable(state) {
+    return state;
+  }
+}
+const on = setInternalModifierManager(new OnModifierManager(), {});
+
+export { on as o };

package/dist/prod/packages/shared-chunks/opcodes-CplRyHl_.js

@@ -0,0 +1,50 @@
+const opcodes = {
+  Append: 1,
+  TrustingAppend: 2,
+  Comment: 3,
+  Modifier: 4,
+  StrictModifier: 5,
+  Block: 6,
+  StrictBlock: 7,
+  Component: 8,
+  OpenElement: 10,
+  OpenElementWithSplat: 11,
+  FlushElement: 12,
+  CloseElement: 13,
+  StaticAttr: 14,
+  DynamicAttr: 15,
+  ComponentAttr: 16,
+  AttrSplat: 17,
+  Yield: 18,
+  DynamicArg: 20,
+  StaticArg: 21,
+  TrustingDynamicAttr: 22,
+  TrustingComponentAttr: 23,
+  StaticComponentAttr: 24,
+  Debugger: 26,
+  Undefined: 27,
+  Call: 28,
+  Concat: 29,
+  GetSymbol: 30,
+  GetLexicalSymbol: 32,
+  GetStrictKeyword: 31,
+  GetFreeAsComponentOrHelperHead: 35,
+  GetFreeAsHelperHead: 37,
+  GetFreeAsModifierHead: 38,
+  GetFreeAsComponentHead: 39,
+  InElement: 40,
+  If: 41,
+  Each: 42,
+  Let: 44,
+  WithDynamicVars: 45,
+  InvokeComponent: 46,
+  HasBlock: 48,
+  HasBlockParams: 49,
+  Curry: 50,
+  Not: 51,
+  IfInline: 52,
+  GetDynamicVar: 53,
+  Log: 54
+};
+
+export { opcodes as o };

package/dist/prod/packages/shared-chunks/or-3AxY5TPj.js

@@ -0,0 +1,91 @@
+import { toBool } from '../@glimmer/global-context/index.js';
+import { a as createComputeRef, v as valueForRef } from './reference-BshxG6wn.js';
+import { i as internalHelper } from './hash-mcs3pEFO.js';
+
+const and = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => {
+    let last;
+    for (let i = 0; i < positional.length; i++) {
+      let arg = positional[i];
+      last = arg ? valueForRef(arg) : arg;
+      if (!toBool(last)) return last;
+    }
+    return last;
+  }, null, 'and');
+});
+
+/**
+ * Performs a strict equality comparison.
+ *
+ * left === right
+ */
+function eq(left, right) {
+  return left === right;
+}
+
+/**
+ * Performs a greater than comparison.
+ *
+ * left > right
+ */
+function gt(left, right) {
+  return left > right;
+}
+
+/**
+ * Performs a greater than or equal comparison.
+ *
+ * left >= right
+ */
+function gte(left, right) {
+  return left >= right;
+}
+
+/**
+ * Performs a less than comparison.
+ *
+ * left < right
+ */
+function lt(left, right) {
+  return left < right;
+}
+
+/**
+ * Performs a less than or equal comparison.
+ *
+ * left <= right
+ */
+function lte(left, right) {
+  return left <= right;
+}
+
+/**
+ * Performs a strict inequality comparison.
+ *
+ * left !== right
+ */
+function neq(left, right) {
+  return left !== right;
+}
+
+const not = (...args) => {
+  return !toBool(args[0]);
+};
+
+const or = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => {
+    let last;
+    for (let i = 0; i < positional.length; i++) {
+      let arg = positional[i];
+      last = arg ? valueForRef(arg) : arg;
+      if (toBool(last)) return last;
+    }
+    return last;
+  }, null, 'or');
+});
+
+export { and as a, gte as b, lte as c, not as d, eq as e, gt as g, lt as l, neq as n, or as o };

package/dist/{dev/packages/shared-chunks/program-DfV0v8aa.js → prod/packages/shared-chunks/program-B7CWdS8W.js}

@@ -1,5 +1,4 @@
-import './debug-to-string-CFb7h0lY.js';
-import { u as unwrap } from './collections-D_nY_0UJ.js';
+import { u as unwrap } from './collections-C3Y8z_9v.js';
 import { O as OPERAND_LEN_MASK, A as ARG_SHIFT, M as MACHINE_MASK, T as TYPE_MASK } from './flags-B9qxc-pB.js';
 
 class RuntimeOpImpl {

package/dist/{dev/packages/shared-chunks/program-context-sJz0oHOA.js → prod/packages/shared-chunks/program-context-B8HKU7wu.js}

@@ -1,7 +1,8 @@
-import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, d as VM_APPEND_HTML_OP, e as VM_APPEND_TEXT_OP, f as VM_RESOLVE_CURRIED_COMPONENT_OP, g as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, h as VM_APPEND_SAFE_HTML_OP, i as VM_APPEND_DOCUMENT_FRAGMENT_OP, j as VM_APPEND_NODE_OP, k as VM_INVOKE_STATIC_OP } from './fragment-Cc5k9Oy4.js';
+import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, c as VM_APPEND_HTML_OP, d as VM_APPEND_TEXT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, g as VM_APPEND_SAFE_HTML_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP } from './syscall-ops-BPFtDquC.js';
+import { V as VM_INVOKE_STATIC_OP } from './vm-ops-ImHv0Wtg.js';
+import { $ as $s0 } from './registers-C_W2qYHJ.js';
 import { ContentType } from '../@glimmer/vm/index.js';
-import { $ as $s0 } from './registers-ylirb0dq.js';
-import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-BUPd6pkm.js';
+import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-Bj71BDDA.js';
 
 class StdLib {
   constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {