ember-primitives 0.41.0 → 0.42.0

package/declarations/on-resize.d.ts

@@ -1,5 +1,6 @@
 import Modifier, { type ArgsFor } from 'ember-modifier';
 import type Owner from '@ember/owner';
+export { ignoreROError } from './resize-observer.ts';
 export interface Signature {
     /**
      * Any element that is resizable can have onResize attached
@@ -23,16 +24,4 @@ declare class OnResize extends Modifier<Signature> {
     modify(element: Element, [callback]: [callback: (entry: ResizeObserverEntry) => void]): void;
 }
 export declare const onResize: typeof OnResize;
-/**
- * Ignores "ResizeObserver loop limit exceeded" error in Ember tests.
- *
- * This "error" is safe to ignore as it is just a warning message,
- * telling that the "looping" observation will be skipped in the current frame,
- * and will be delivered in the next one.
- *
- * For some reason, it is fired as an `error` event at `window` failing Ember
- * tests and exploding Sentry with errors that must be ignored.
- */
-export default function ignoreROError(): void;
-export {};
 //# sourceMappingURL=on-resize.d.ts.map

package/declarations/on-resize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"on-resize.d.ts","sourceRoot":"","sources":["../src/on-resize.ts"],"names":[],"mappings":"AAGA,OAAO,QAAQ,EAAE,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACJ,UAAU,EAAE;YACV;;;;;eAKG;YACH,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;SAC/C,CAAC;KACH,CAAC;CACH;AAED,cAAM,QAAS,SAAQ,QAAQ,CAAC,SAAS,CAAC;;gBAM5B,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC;IAUlD,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,CAAC;CAetF;AAED,eAAO,MAAM,QAAQ,iBAAW,CAAC;AA6EjC;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,SAgBpC"}
+{"version":3,"file":"on-resize.d.ts","sourceRoot":"","sources":["../src/on-resize.ts"],"names":[],"mappings":"AAGA,OAAO,QAAQ,EAAE,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAIxD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACJ,UAAU,EAAE;YACV;;;;;eAKG;YACH,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;SAC/C,CAAC;KACH,CAAC;CACH;AAED,cAAM,QAAS,SAAQ,QAAQ,CAAC,SAAS,CAAC;;gBAM5B,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC;IAUlD,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,CAAC;CAetF;AAED,eAAO,MAAM,QAAQ,iBAAW,CAAC"}

package/declarations/resize-observer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Creates or returns the ResizeObserverManager.
+ *
+ * Only one of these will exist per owner.
+ *
+ * Has only two methods:
+ * - observe(element, callback: (resizeObserverEntry) => void)
+ * - unobserve(element, callback: (resizeObserverEntry) => void)
+ *
+ * Like with the underlying ResizeObserver API (and all event listeners),
+ * the callback passed to unobserved must be the same reference as the one
+ * passed to observe.
+ */
+export declare function resizeObserver(context: object): ResizeObserverManager;
+declare class ResizeObserverManager {
+    #private;
+    constructor();
+    /**
+     * Initiate the observing of the `element` or add an additional `callback`
+     * if the `element` is already observed.
+     *
+     * @param {object} element
+     * @param {function} callback The `callback` is called whenever the size of
+     *    the `element` changes. It is called with `ResizeObserverEntry` object
+     *    for the particular `element`.
+     */
+    observe(element: Element, callback: (entry: ResizeObserverEntry) => unknown): void;
+    /**
+     * End the observing of the `element` or just remove the provided `callback`.
+     *
+     * It will unobserve the `element` if the `callback` is not provided
+     * or there are no more callbacks left for this `element`.
+     *
+     * @param {object} element
+     * @param {function?} callback - The `callback` to remove from the listeners
+     *   of the `element` size changes.
+     */
+    unobserve(element: Element, callback: (entry: ResizeObserverEntry) => unknown): void;
+}
+/**
+ * Ignores "ResizeObserver loop limit exceeded" error in Ember tests.
+ *
+ * This "error" is safe to ignore as it is just a warning message,
+ * telling that the "looping" observation will be skipped in the current frame,
+ * and will be delivered in the next one.
+ *
+ * For some reason, it is fired as an `error` event at `window` failing Ember
+ * tests and exploding Sentry with errors that must be ignored.
+ */
+export declare function ignoreROError(): void;
+export {};
+//# sourceMappingURL=resize-observer.d.ts.map

package/declarations/resize-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-observer.d.ts","sourceRoot":"","sources":["../src/resize-observer.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,yBAS7C;AAED,cAAM,qBAAqB;;;IAwBzB;;;;;;;;OAQG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO;IAW3E;;;;;;;;;OASG;IACH,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO;CAc9E;AAOD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,SAgB5B"}

package/declarations/utils.d.ts

@@ -1,3 +1,27 @@
+import type Owner from '@ember/owner';
 export declare function uniqueId(): string;
 export declare function isNewable(x: any): x is new (...args: unknown[]) => NonNullable<object>;
+/**
+ * Loose check for an "ownerish" API.
+ * only the ".lookup" method is required.
+ *
+ * The requirements for what an "owner" is are sort of undefined,
+ * as the actual owner in ember applications has too much on it,
+ * and the long term purpose of the owner will be questioned once we
+ * eliminate the need to have a registry (what lookup looks in to),
+ * but we'll still need "Something" to represent the lifetime of the application.
+ *
+ * Technically, the owner could be any object, including `{}`
+ */
+export declare function isOwner(x: unknown): x is Owner;
+export declare function isNonNullableObject(x: unknown): x is NonNullable<object>;
+/**
+ * Can receive the class instance or the owner itself, and will always return return the owner.
+ *
+ * undefined will be returned if the Owner does not exist on the passed object
+ *
+ * Can be useful when combined with `createStore` to then create "services",
+ * which don't require string lookup.
+ */
+export declare function findOwner(contextOrOwner: unknown): Owner | undefined;
 //# sourceMappingURL=utils.d.ts.map

package/declarations/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,IAAI,MAAM,CAQjC;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,WAAW,CAAC,MAAM,CAAC,CAGtF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAItC,wBAAgB,QAAQ,IAAI,MAAM,CAQjC;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,WAAW,CAAC,MAAM,CAAC,CAMtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,KAAK,CAI9C;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,WAAW,CAAC,MAAM,CAAC,CAKxE;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,cAAc,EAAE,OAAO,GAAG,KAAK,GAAG,SAAS,CAWpE"}

package/dist/on-resize.js

@@ -2,11 +2,13 @@
 import { assert } from '@ember/debug';
 import { registerDestructor } from '@ember/destroyable';
 import Modifier from 'ember-modifier';
+import { resizeObserver } from './resize-observer.js';
+export { ignoreROError } from './resize-observer.js';
 
 class OnResize extends Modifier {
   #callback = null;
   #element = null;
-  #resizeObserver = new ResizeObserverManager();
+  #resizeObserver = resizeObserver(this);
   constructor(owner, args) {
     super(owner, args);
     registerDestructor(this, () => {
@@ -26,92 +28,6 @@ class OnResize extends Modifier {
   }
 }
 const onResize = OnResize;
-const errorMessages = ['ResizeObserver loop limit exceeded', 'ResizeObserver loop completed with undelivered notifications.'];
-class ResizeObserverManager {
-  #callbacks = new WeakMap();
-  #handleResize = entries => {
-    for (const entry of entries) {
-      const callbacks = this.#callbacks.get(entry.target);
-      if (callbacks) {
-        for (const callback of callbacks) {
-          callback(entry);
-        }
-      }
-    }
-  };
-  #observer = new ResizeObserver(this.#handleResize);
-  constructor() {
-    ignoreROError();
-    registerDestructor(this, () => {
-      this.#observer?.disconnect();
-    });
-  }
-
-  /**
-   * Initiate the observing of the `element` or add an additional `callback`
-   * if the `element` is already observed.
-   *
-   * @param {object} element
-   * @param {function} callback The `callback` is called whenever the size of
-   *    the `element` changes. It is called with `ResizeObserverEntry` object
-   *    for the particular `element`.
-   */
-  observe(element, callback) {
-    const callbacks = this.#callbacks.get(element);
-    if (callbacks) {
-      callbacks.add(callback);
-    } else {
-      this.#callbacks.set(element, new Set([callback]));
-      this.#observer.observe(element);
-    }
-  }
-
-  /**
-   * End the observing of the `element` or just remove the provided `callback`.
-   *
-   * It will unobserve the `element` if the `callback` is not provided
-   * or there are no more callbacks left for this `element`.
-   *
-   * @param {object} element
-   * @param {function?} callback - The `callback` to remove from the listeners
-   *   of the `element` size changes.
-   */
-  unobserve(element, callback) {
-    const callbacks = this.#callbacks.get(element);
-    if (!callbacks) {
-      return;
-    }
-    callbacks.delete(callback);
-    if (!callback || !callbacks.size) {
-      this.#callbacks.delete(element);
-      this.#observer.unobserve(element);
-    }
-  }
-}
-
-/**
- * Ignores "ResizeObserver loop limit exceeded" error in Ember tests.
- *
- * This "error" is safe to ignore as it is just a warning message,
- * telling that the "looping" observation will be skipped in the current frame,
- * and will be delivered in the next one.
- *
- * For some reason, it is fired as an `error` event at `window` failing Ember
- * tests and exploding Sentry with errors that must be ignored.
- */
-function ignoreROError() {
-  if (typeof window.onerror !== 'function') {
-    return;
-  }
-  const onError = window.onerror;
-  window.onerror = (...args) => {
-    const [message] = args;
-    if (typeof message === 'string') {
-      if (errorMessages.includes(message)) return true;
-    }
-    onError(...args);
-  };
-}
 
-export { ignoreROError as default, onResize };
+export { onResize };
 //# sourceMappingURL=on-resize.js.map

package/dist/resize-observer.js

@@ -0,0 +1,113 @@
+
+import { assert } from '@ember/debug';
+import { registerDestructor } from '@ember/destroyable';
+import { createStore } from './store.js';
+import { findOwner } from './utils.js';
+
+/**
+ * Creates or returns the ResizeObserverManager.
+ *
+ * Only one of these will exist per owner.
+ *
+ * Has only two methods:
+ * - observe(element, callback: (resizeObserverEntry) => void)
+ * - unobserve(element, callback: (resizeObserverEntry) => void)
+ *
+ * Like with the underlying ResizeObserver API (and all event listeners),
+ * the callback passed to unobserved must be the same reference as the one
+ * passed to observe.
+ */
+function resizeObserver(context) {
+  const owner = findOwner(context);
+  assert(`Could not find owner on the passed context (to resizeObserver). resizeObserver can only be used on an object whos lifetime is in someone entangled with the application (which incidentally has an "owner").`, owner);
+  return createStore(owner, ResizeObserverManager);
+}
+class ResizeObserverManager {
+  #callbacks = new WeakMap();
+  #handleResize = entries => {
+    for (const entry of entries) {
+      const callbacks = this.#callbacks.get(entry.target);
+      if (callbacks) {
+        for (const callback of callbacks) {
+          callback(entry);
+        }
+      }
+    }
+  };
+  #observer = new ResizeObserver(this.#handleResize);
+  constructor() {
+    ignoreROError();
+    registerDestructor(this, () => {
+      this.#observer?.disconnect();
+    });
+  }
+
+  /**
+   * Initiate the observing of the `element` or add an additional `callback`
+   * if the `element` is already observed.
+   *
+   * @param {object} element
+   * @param {function} callback The `callback` is called whenever the size of
+   *    the `element` changes. It is called with `ResizeObserverEntry` object
+   *    for the particular `element`.
+   */
+  observe(element, callback) {
+    const callbacks = this.#callbacks.get(element);
+    if (callbacks) {
+      callbacks.add(callback);
+    } else {
+      this.#callbacks.set(element, new Set([callback]));
+      this.#observer.observe(element);
+    }
+  }
+
+  /**
+   * End the observing of the `element` or just remove the provided `callback`.
+   *
+   * It will unobserve the `element` if the `callback` is not provided
+   * or there are no more callbacks left for this `element`.
+   *
+   * @param {object} element
+   * @param {function?} callback - The `callback` to remove from the listeners
+   *   of the `element` size changes.
+   */
+  unobserve(element, callback) {
+    const callbacks = this.#callbacks.get(element);
+    if (!callbacks) {
+      return;
+    }
+    callbacks.delete(callback);
+    if (!callback || !callbacks.size) {
+      this.#callbacks.delete(element);
+      this.#observer.unobserve(element);
+    }
+  }
+}
+const errorMessages = ['ResizeObserver loop limit exceeded', 'ResizeObserver loop completed with undelivered notifications.'];
+
+/**
+ * Ignores "ResizeObserver loop limit exceeded" error in Ember tests.
+ *
+ * This "error" is safe to ignore as it is just a warning message,
+ * telling that the "looping" observation will be skipped in the current frame,
+ * and will be delivered in the next one.
+ *
+ * For some reason, it is fired as an `error` event at `window` failing Ember
+ * tests and exploding Sentry with errors that must be ignored.
+ */
+function ignoreROError() {
+  if (typeof window.onerror !== 'function') {
+    return;
+  }
+  const onError = window.onerror;
+  window.onerror = (...args) => {
+    const [message] = args;
+    if (typeof message === 'string') {
+      if (errorMessages.includes(message)) return true;
+    }
+    onError(...args);
+  };
+}
+
+export { ignoreROError, resizeObserver };
+//# sourceMappingURL=resize-observer.js.map

package/dist/resize-observer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-observer.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/utils.js

@@ -1,4 +1,6 @@
 
+import { getOwner } from '@ember/owner';
+
 // this is copy pasted from https://github.com/emberjs/ember.js/blob/60d2e0cddb353aea0d6e36a72fda971010d92355/packages/%40ember/-internals/glimmer/lib/helpers/unique-id.ts
 // Unfortunately due to https://github.com/emberjs/ember.js/issues/20165 we cannot use the built-in version in template tags
 function uniqueId() {
@@ -9,9 +11,52 @@ function uniqueId() {
   return ([3e7] + -1e3 + -4e3 + -2e3 + -1e11).replace(/[0-3]/g, a => (a * 4 ^ Math.random() * 16 >> (a & 2)).toString(16));
 }
 function isNewable(x) {
+  // TypeScript has really bad prototype support -- they don't really
+  // want folks using this sort of stuff -- but it's handy for perf and all that.
+  //
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
   return x.prototype?.constructor === x;
 }
 
-export { isNewable, uniqueId };
+/**
+ * Loose check for an "ownerish" API.
+ * only the ".lookup" method is required.
+ *
+ * The requirements for what an "owner" is are sort of undefined,
+ * as the actual owner in ember applications has too much on it,
+ * and the long term purpose of the owner will be questioned once we
+ * eliminate the need to have a registry (what lookup looks in to),
+ * but we'll still need "Something" to represent the lifetime of the application.
+ *
+ * Technically, the owner could be any object, including `{}`
+ */
+function isOwner(x) {
+  if (!isNonNullableObject(x)) return false;
+  return 'lookup' in x && typeof x.lookup === 'function';
+}
+function isNonNullableObject(x) {
+  if (typeof x !== 'object') return false;
+  if (x === null) return false;
+  return true;
+}
+
+/**
+ * Can receive the class instance or the owner itself, and will always return return the owner.
+ *
+ * undefined will be returned if the Owner does not exist on the passed object
+ *
+ * Can be useful when combined with `createStore` to then create "services",
+ * which don't require string lookup.
+ */
+function findOwner(contextOrOwner) {
+  if (isOwner(contextOrOwner)) return contextOrOwner;
+
+  // _ENSURE_ that we have an object, else getOwner makes no sense to call
+  if (!isNonNullableObject(contextOrOwner)) return;
+  const maybeOwner = getOwner(contextOrOwner);
+  if (isOwner(maybeOwner)) return maybeOwner;
+  return;
+}
+
+export { findOwner, isNewable, isNonNullableObject, isOwner, uniqueId };
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-primitives",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "description": "Making apps easier to build",
   "keywords": [
     "ember-addon"