@signaldb/core 1.7.2 → 1.8.0

package/dist/.vite/manifest.json

@@ -15,11 +15,12 @@
     "imports": [
       "src/utils/sortItems.ts",
       "src/utils/project.ts",
+      "src/utils/deepClone.ts",
       "src/Collection/Observer.ts"
     ]
   },
   "src/Collection/Observer.ts": {
-    "file": "index.cjs17.js",
+    "file": "index.cjs18.js",
     "name": "Collection/Observer",
     "src": "src/Collection/Observer.ts",
     "imports": [
@@ -135,7 +136,7 @@
     "src": "src/utils/createSignal.ts"
   },
   "src/utils/deepClone.ts": {
-    "file": "index.cjs19.js",
+    "file": "index.cjs17.js",
     "name": "utils/deepClone",
     "src": "src/utils/deepClone.ts"
   },
@@ -169,7 +170,7 @@
     "src": "src/utils/isFieldExpression.ts"
   },
   "src/utils/match.ts": {
-    "file": "index.cjs18.js",
+    "file": "index.cjs19.js",
     "name": "utils/match",
     "src": "src/utils/match.ts"
   },

package/dist/AutoFetchCollection.d.ts

@@ -10,11 +10,11 @@ interface AutoFetchOptions<T extends {
     registerRemoteChange?: (onChange: () => Promise<void>) => Promise<void>;
     mergeItems?: (itemA: T, itemB: T) => T;
 }
-export type AutoFetchCollectionOptions<T extends BaseItem<I>, I, U = T> = Omit<ReplicatedCollectionOptions<T, I, U>, 'pull' | 'registerRemoteChange'> & AutoFetchOptions<T, I>;
+export type AutoFetchCollectionOptions<T extends BaseItem<I>, I, E extends BaseItem = T, U = E> = Omit<ReplicatedCollectionOptions<T, I, E, U>, 'pull' | 'registerRemoteChange'> & AutoFetchOptions<T, I>;
 /**
  * A special collection that automatically fetches items when they are needed.
  */
-export default class AutoFetchCollection<T extends BaseItem<I> = BaseItem, I = any, U = T> extends ReplicatedCollection<T, I, U> {
+export default class AutoFetchCollection<T extends BaseItem<I> = BaseItem, I = any, E extends BaseItem = T, U = E> extends ReplicatedCollection<T, I, E, U> {
     private activeObservers;
     private observerTimeouts;
     private purgeDelay;
@@ -31,7 +31,7 @@ export default class AutoFetchCollection<T extends BaseItem<I> = BaseItem, I = a
      * @param options.fetchQueryItems {Function} - A function that fetches items from the server. It takes the selector as an argument and returns a promise that resolves to an object with an `items` property.
      * @param options.purgeDelay {Number} - The delay in milliseconds before purging an item from the cache.
      */
-    constructor(options: AutoFetchCollectionOptions<T, I, U>);
+    constructor(options: AutoFetchCollectionOptions<T, I, E, U>);
     /**
      * Registers a query manually that items should be fetched for it
      * @param selector {Object} Selector of the query

package/dist/Collection/Cursor.d.ts

@@ -1,5 +1,5 @@
 import type ReactivityAdapter from '../types/ReactivityAdapter';
-import type { BaseItem, FindOptions, Transform } from './types';
+import type { BaseItem, FindOptions, Transform, TransformAll } from './types';
 import type { ObserveCallbacks } from './Observer';
 /**
  * Checks if the current scope is reactive, considering the provided reactivity adapter.
@@ -7,17 +7,19 @@ import type { ObserveCallbacks } from './Observer';
  * @returns A boolean indicating if the current scope is reactive.
  */
 export declare function isInReactiveScope(reactivity: ReactivityAdapter | undefined | false): boolean;
-export interface CursorOptions<T extends BaseItem, U = T> extends FindOptions<T> {
-    transform?: Transform<T, U>;
+export interface CursorOptions<T extends BaseItem, E extends BaseItem = T, U = E> extends FindOptions<T> {
+    transformAll?: TransformAll<T, E>;
+    transform?: Transform<E, U>;
     bindEvents?: (requery: () => void) => () => void;
 }
 /**
  * Represents a cursor for querying and observing a filtered, sorted, and transformed
  * subset of items from a collection. Supports reactivity and field tracking.
  * @template T - The type of the items in the collection.
- * @template U - The transformed item type after applying transformations (default is T).
+ * @template E - The transformed item type after applying transformAll (default is T).
+ * @template U - The transformed item type after applying transform (default is E).
  */
-export default class Cursor<T extends BaseItem, U = T> {
+export default class Cursor<T extends BaseItem, E extends BaseItem = T, U = E> {
     private observer;
     private getFilteredItems;
     private options;
@@ -37,8 +39,9 @@ export default class Cursor<T extends BaseItem, U = T> {
      * @param options.limit - The maximum number of items to return in the result set.
      * @param options.reactive - A reactivity adapter to enable observing changes in the cursor's result set.
      * @param options.fieldTracking - A boolean to enable fine-grained field tracking for reactivity.
+     * @param options.transformAll - A function that will be able to solve the n+1 problem
      */
-    constructor(getItems: () => T[], options?: CursorOptions<T, U>);
+    constructor(getItems: () => T[], options?: CursorOptions<T, E, U>);
     private addGetters;
     private transform;
     private getItems;
@@ -102,7 +105,7 @@ export default class Cursor<T extends BaseItem, U = T> {
      * @param skipInitial - A boolean indicating whether to skip the initial notification of the current result set.
      * @returns A function to stop observing changes.
      */
-    observeChanges(callbacks: ObserveCallbacks<U>, skipInitial?: boolean): () => void;
+    observeChanges(callbacks: ObserveCallbacks<E>, skipInitial?: boolean): () => void;
     /**
      * Forces the cursor to re-evaluate its result set by re-fetching items
      * from the collection. This is useful when the underlying data or query

package/dist/Collection/index.d.ts

@@ -6,23 +6,24 @@ import type Selector from '../types/Selector';
 import type Modifier from '../types/Modifier';
 import type IndexProvider from '../types/IndexProvider';
 import Cursor from './Cursor';
-import type { BaseItem, FindOptions, Transform } from './types';
-export type { BaseItem, Transform, SortSpecifier, FieldSpecifier, FindOptions } from './types';
+import type { BaseItem, FindOptions, Transform, TransformAll } from './types';
+export type { BaseItem, Transform, TransformAll, SortSpecifier, FieldSpecifier, FindOptions } from './types';
 export type { CursorOptions } from './Cursor';
 export type { ObserveCallbacks } from './Observer';
 export { default as createIndex } from './createIndex';
-export interface CollectionOptions<T extends BaseItem<I>, I, U = T> {
+export interface CollectionOptions<T extends BaseItem<I>, I, E extends BaseItem = T, U = E> {
     name?: string;
     memory?: MemoryAdapter;
     reactivity?: ReactivityAdapter;
-    transform?: Transform<T, U>;
+    transform?: Transform<E, U>;
     persistence?: PersistenceAdapter<T, I>;
     indices?: IndexProvider<T, I>[];
     enableDebugMode?: boolean;
     fieldTracking?: boolean;
+    transformAll?: TransformAll<T, E>;
     primaryKeyGenerator?: (item: Omit<T, 'id'>) => I;
 }
-interface CollectionEvents<T extends BaseItem, U = T> {
+interface CollectionEvents<T extends BaseItem, E extends BaseItem = T, U = E> {
     'added': (item: T) => void;
     'changed': (item: T, modifier: Modifier<T>) => void;
     'removed': (item: T) => void;
@@ -37,7 +38,7 @@ interface CollectionEvents<T extends BaseItem, U = T> {
     'observer.created': <O extends FindOptions<T>>(selector?: Selector<T>, options?: O) => void;
     'observer.disposed': <O extends FindOptions<T>>(selector?: Selector<T>, options?: O) => void;
     'getItems': (selector: Selector<T> | undefined) => void;
-    'find': <O extends FindOptions<T>>(selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, U>) => void;
+    'find': <O extends FindOptions<T>>(selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, E, U>) => void;
     'findOne': <O extends FindOptions<T>>(selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
     'insert': (item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
     'updateOne': (selector: Selector<T>, modifier: Modifier<T>) => void;
@@ -47,7 +48,7 @@ interface CollectionEvents<T extends BaseItem, U = T> {
     'removeMany': (selector: Selector<T>) => void;
     'validate': (item: T) => void;
     '_debug.getItems': (callstack: string, selector: Selector<T> | undefined, measuredTime: number) => void;
-    '_debug.find': <O extends FindOptions<T>>(callstack: string, selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, U>) => void;
+    '_debug.find': <O extends FindOptions<T>>(callstack: string, selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, E, U>) => void;
     '_debug.findOne': <O extends FindOptions<T>>(callstack: string, selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
     '_debug.insert': (callstack: string, item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
     '_debug.updateOne': (callstack: string, selector: Selector<T>, modifier: Modifier<T>) => void;
@@ -64,14 +65,14 @@ interface CollectionEvents<T extends BaseItem, U = T> {
  * @template I - The type of the unique identifier for the items.
  * @template U - The transformed item type after applying transformations (default is T).
  */
-export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T> extends EventEmitter<CollectionEvents<T, U>> {
+export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E extends BaseItem = T, U = E> extends EventEmitter<CollectionEvents<T, E, U>> {
     private static collections;
     private static debugMode;
     private static batchOperationInProgress;
     private static fieldTracking;
     private static onCreationCallbacks;
     private static onDisposeCallbacks;
-    static getCollections(): Collection<any, any, any>[];
+    static getCollections(): Collection<any, any, any, any>[];
     static onCreation(callback: (collection: Collection<any>) => void): void;
     static onDispose(callback: (collection: Collection<any>) => void): void;
     /**
@@ -105,6 +106,7 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
     private postBatchCallbacks;
     private fieldTracking;
     private persistenceReadyPromise;
+    private pendingUpdates;
     /**
      * Initializes a new instance of the `Collection` class with optional configuration.
      * Sets up memory, persistence, reactivity, and indices as specified in the options.
@@ -120,8 +122,21 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      * @param options.indices - An array of index providers for optimized querying.
      * @param options.enableDebugMode - A boolean to enable or disable debug mode.
      * @param options.fieldTracking - A boolean to enable or disable field tracking by default.
+     * @param options.transformAll - A function that will be able to solve the n+1 problem
      */
-    constructor(options?: CollectionOptions<T, I, U>);
+    constructor(options?: CollectionOptions<T, I, E, U>);
+    /**
+     * Resets the collection's data by clearing the in-memory items and reloading from the persistence adapter.
+     * @returns A promise that resolves when the data has been reset and reloaded.
+     */
+    resetData(): Promise<void>;
+    /**
+     * Loads data from the persistence adapter and updates the in-memory collection accordingly.
+     * @param data - Optional data to load, containing either a full list of items or a set of changes. If not provided, data will be loaded from the persistence adapter.
+     * @param hasOngoingSaves - A boolean indicating whether there are ongoing save operations. If `true`, the method will skip loading data to avoid conflicts with pending updates.
+     * @returns A promise that resolves when the data has been loaded and the in-memory collection has been updated.
+     */
+    private loadPersistentData;
     /**
      * Checks whether the collection is currently performing a pull operation
      * ⚡️ this function is reactive!
@@ -183,6 +198,7 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
     private memory;
     private memoryArray;
     private transform;
+    private transformAll;
     private getItems;
     /**
      * Disposes the collection, unregisters persistence adapters, clears memory, and
@@ -198,7 +214,7 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      * @param [options] - Options for the find operation, such as limit and sort.
      * @returns A cursor to fetch and observe the matching items.
      */
-    find<O extends FindOptions<T>>(selector?: Selector<T>, options?: O): Cursor<T, U>;
+    find<O extends FindOptions<T>>(selector?: Selector<T>, options?: O): Cursor<T, E, U>;
     /**
      * Finds a single item in the collection based on a selector and optional options.
      * ⚡️ this function is reactive!

package/dist/Collection/types.d.ts

@@ -3,6 +3,7 @@ export type BaseItem<I = any> = {
     id: I;
 } & Record<string, any>;
 export type Transform<T, U = T> = ((document: T) => U) | null | undefined;
+export type TransformAll<T extends BaseItem, O extends BaseItem = T> = ((items: T[], fields: FieldSpecifier<O> | undefined) => O[]) | null | undefined;
 export type SortSpecifier<T> = {
     [P in keyof T]?: -1 | 1;
 } & Record<string, -1 | 1>;

package/dist/ReplicatedCollection.d.ts

@@ -22,7 +22,7 @@ interface ReplicationOptions<T extends {
 export declare function createReplicationAdapter<T extends {
     id: I;
 } & Record<string, any>, I>(options: ReplicationOptions<T, I>): import("./types/PersistenceAdapter").default<T, unknown>;
-export type ReplicatedCollectionOptions<T extends BaseItem<I>, I, U = T> = CollectionOptions<T, I, U> & ReplicationOptions<T, I>;
+export type ReplicatedCollectionOptions<T extends BaseItem<I>, I, E extends BaseItem = T, U = E> = CollectionOptions<T, I, E, U> & ReplicationOptions<T, I>;
 /**
  * Extends the `Collection` class to support replication with remote sources.
  * Handles pull and push operations, remote change registration, and enhanced loading states.
@@ -30,7 +30,7 @@ export type ReplicatedCollectionOptions<T extends BaseItem<I>, I, U = T> = Colle
  * @template I - The type of the unique identifier for the items.
  * @template U - The transformed item type after applying transformations (default is T).
  */
-export default class ReplicatedCollection<T extends BaseItem<I> = BaseItem, I = any, U = T> extends Collection<T, I, U> {
+export default class ReplicatedCollection<T extends BaseItem<I> = BaseItem, I = any, E extends BaseItem = T, U = E> extends Collection<T, I, E, U> {
     private isPullingRemoteSignal;
     private isPushingRemoteSignal;
     /**
@@ -47,7 +47,7 @@ export default class ReplicatedCollection<T extends BaseItem<I> = BaseItem, I =
      * @param options.indices - An array of index providers for optimized querying.
      * @param options.enableDebugMode - A boolean to enable or disable debug mode.
      */
-    constructor(options: ReplicatedCollectionOptions<T, I, U>);
+    constructor(options: ReplicatedCollectionOptions<T, I, E, U>);
     /**
      * Checks whether the collection is currently performing any loading operation,
      * including pulling or pushing data from/to the remote source, or standard

package/dist/index.cjs11.js

@@ -1,6 +1,6 @@
 "use strict";
 const mingo = require("mingo");
-const deepClone = require("./index.cjs19.js");
+const deepClone = require("./index.cjs17.js");
 function modify(item, modifier) {
   const hasOperators = Object.keys(modifier).some((key) => key.startsWith("$"));
   if (!hasOperators)

package/dist/index.cjs17.js

@@ -1,142 +1,42 @@
 "use strict";
-const isEqual = require("./index.cjs10.js");
-const uniqueBy = require("./index.cjs26.js");
-class Observer {
-  previousItems = [];
-  callbacks;
-  unbindEvents;
-  /**
-   * Creates a new instance of the `Observer` class.
-   * Sets up event bindings and initializes the callbacks for tracking changes in a collection.
-   * @param bindEvents - A function to bind external events to the observer. Must return a cleanup function to unbind those events.
-   */
-  constructor(bindEvents) {
-    this.callbacks = {
-      added: [],
-      addedBefore: [],
-      changed: [],
-      changedField: [],
-      movedBefore: [],
-      removed: []
-    };
-    this.unbindEvents = bindEvents();
-  }
-  call(event, ...args) {
-    this.callbacks[event].forEach(({ callback, options }) => {
-      if (!options.skipInitial || !options.isInitial) {
-        callback(...args);
-      }
-    });
-  }
-  hasCallbacks(events) {
-    return events.some((event) => this.callbacks[event].length > 0);
-  }
-  /**
-   * Determines if the observer has no active callbacks registered for any events.
-   * @returns A boolean indicating whether the observer is empty (i.e., no callbacks are registered).
-   */
-  isEmpty() {
-    return !this.hasCallbacks([
-      "added",
-      "addedBefore",
-      "changed",
-      "changedField",
-      "movedBefore",
-      "removed"
-    ]);
-  }
-  /**
-   * Compares the previous state of items with the new state and triggers the appropriate callbacks
-   * for events such as added, removed, changed, or moved items.
-   * @param newItems - The new list of items to compare against the previous state.
-   */
-  runChecks(newItems) {
-    const oldItemsMap = new Map(this.previousItems.map((item, index) => [
-      item.id,
-      { item, index, beforeItem: this.previousItems[index + 1] || null }
-    ]));
-    const newItemsMap = new Map(newItems.map((item, index) => [
-      item.id,
-      { item, index, beforeItem: newItems[index + 1] || null }
-    ]));
-    if (this.hasCallbacks(["changed", "changedField", "movedBefore", "removed"])) {
-      oldItemsMap.forEach(({ item: oldItem, index, beforeItem: oldBeforeItem }) => {
-        const newItem = newItemsMap.get(oldItem.id);
-        if (newItem) {
-          if (this.hasCallbacks(["changed", "changedField"]) && !isEqual(newItem.item, oldItem)) {
-            this.call("changed", newItem.item);
-            if (this.hasCallbacks(["changedField"])) {
-              const keys = uniqueBy([
-                ...Object.keys(newItem.item),
-                ...Object.keys(oldItem)
-              ], (value) => value);
-              keys.forEach((key) => {
-                if (isEqual(newItem.item[key], oldItem[key]))
-                  return;
-                this.call("changedField", newItem.item, key, oldItem[key], newItem.item[key]);
-              });
-            }
-          }
-          if (newItem.index !== index && newItem.beforeItem?.id !== oldBeforeItem?.id) {
-            this.call("movedBefore", newItem.item, newItem.beforeItem);
-          }
-        } else {
-          this.call("removed", oldItem);
-        }
-      });
-    }
-    if (this.hasCallbacks(["added", "addedBefore"])) {
-      newItems.forEach((newItem, index) => {
-        const oldItem = oldItemsMap.get(newItem.id);
-        if (oldItem)
-          return;
-        this.call("added", newItem);
-        this.call("addedBefore", newItem, newItems[index + 1] || null);
-      });
-    }
-    this.previousItems = newItems;
-    Object.keys(this.callbacks).forEach((key) => {
-      const event = key;
-      const callbacks = this.callbacks[event];
-      this.callbacks[event] = callbacks.map((callback) => ({
-        ...callback,
-        options: {
-          ...callback.options,
-          isInitial: false
-        }
-      }));
-    });
-  }
-  /**
-   * Stops the observer by unbinding all events and cleaning up resources.
-   */
-  stop() {
-    this.unbindEvents();
-  }
-  /**
-   * Registers callbacks for specific events to observe changes in the collection.
-   * @param callbacks - An object containing the callbacks for various events (e.g., 'added', 'removed').
-   * @param skipInitial - A boolean indicating whether to skip invoking the callbacks for the initial state of the collection.
-   */
-  addCallbacks(callbacks, skipInitial = false) {
-    Object.keys(callbacks).forEach((key) => {
-      const typedKey = key;
-      this.callbacks[typedKey].push({
-        callback: callbacks[typedKey],
-        options: { skipInitial, isInitial: true }
-      });
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function clone(value) {
+  if (typeof value === "function")
+    throw new Error("Cloning functions is not supported");
+  if (value === null || typeof value !== "object")
+    return value;
+  if (value instanceof Date)
+    return new Date(value);
+  if (Array.isArray(value))
+    return value.map((item) => clone(item));
+  if (value instanceof Map) {
+    const result2 = /* @__PURE__ */ new Map();
+    value.forEach((currentValue, key) => {
+      result2.set(key, clone(currentValue));
     });
+    return result2;
   }
-  /**
-   * Removes the specified callbacks for specific events, unregistering them from the observer.
-   * @param callbacks - An object containing the callbacks to be removed for various events.
-   */
-  removeCallbacks(callbacks) {
-    Object.keys(callbacks).forEach((key) => {
-      const typedKey = key;
-      const index = this.callbacks[typedKey].findIndex(({ callback }) => callback === callbacks[typedKey]);
-      this.callbacks[typedKey].splice(index, 1);
+  if (value instanceof Set) {
+    const result2 = /* @__PURE__ */ new Set();
+    value.forEach((currentValue) => {
+      result2.add(clone(currentValue));
     });
+    return result2;
+  }
+  if (value instanceof RegExp)
+    return new RegExp(value);
+  const result = {};
+  for (const key in value) {
+    if (Object.hasOwnProperty.call(value, key)) {
+      result[key] = clone(value[key]);
+    }
   }
+  return result;
+}
+function deepClone(object) {
+  if (typeof structuredClone === "function")
+    return structuredClone(object);
+  return clone(object);
 }
-module.exports = Observer;
+exports.clone = clone;
+exports.default = deepClone;

package/dist/index.cjs18.js

@@ -1,7 +1,142 @@
 "use strict";
-const mingo = require("mingo");
-function match(item, selector) {
-  const query = new mingo.Query(selector);
-  return query.test(item);
+const isEqual = require("./index.cjs10.js");
+const uniqueBy = require("./index.cjs26.js");
+class Observer {
+  previousItems = [];
+  callbacks;
+  unbindEvents;
+  /**
+   * Creates a new instance of the `Observer` class.
+   * Sets up event bindings and initializes the callbacks for tracking changes in a collection.
+   * @param bindEvents - A function to bind external events to the observer. Must return a cleanup function to unbind those events.
+   */
+  constructor(bindEvents) {
+    this.callbacks = {
+      added: [],
+      addedBefore: [],
+      changed: [],
+      changedField: [],
+      movedBefore: [],
+      removed: []
+    };
+    this.unbindEvents = bindEvents();
+  }
+  call(event, ...args) {
+    this.callbacks[event].forEach(({ callback, options }) => {
+      if (!options.skipInitial || !options.isInitial) {
+        callback(...args);
+      }
+    });
+  }
+  hasCallbacks(events) {
+    return events.some((event) => this.callbacks[event].length > 0);
+  }
+  /**
+   * Determines if the observer has no active callbacks registered for any events.
+   * @returns A boolean indicating whether the observer is empty (i.e., no callbacks are registered).
+   */
+  isEmpty() {
+    return !this.hasCallbacks([
+      "added",
+      "addedBefore",
+      "changed",
+      "changedField",
+      "movedBefore",
+      "removed"
+    ]);
+  }
+  /**
+   * Compares the previous state of items with the new state and triggers the appropriate callbacks
+   * for events such as added, removed, changed, or moved items.
+   * @param newItems - The new list of items to compare against the previous state.
+   */
+  runChecks(newItems) {
+    const oldItemsMap = new Map(this.previousItems.map((item, index) => [
+      item.id,
+      { item, index, beforeItem: this.previousItems[index + 1] || null }
+    ]));
+    const newItemsMap = new Map(newItems.map((item, index) => [
+      item.id,
+      { item, index, beforeItem: newItems[index + 1] || null }
+    ]));
+    if (this.hasCallbacks(["changed", "changedField", "movedBefore", "removed"])) {
+      oldItemsMap.forEach(({ item: oldItem, index, beforeItem: oldBeforeItem }) => {
+        const newItem = newItemsMap.get(oldItem.id);
+        if (newItem) {
+          if (this.hasCallbacks(["changed", "changedField"]) && !isEqual(newItem.item, oldItem)) {
+            this.call("changed", newItem.item);
+            if (this.hasCallbacks(["changedField"])) {
+              const keys = uniqueBy([
+                ...Object.keys(newItem.item),
+                ...Object.keys(oldItem)
+              ], (value) => value);
+              keys.forEach((key) => {
+                if (isEqual(newItem.item[key], oldItem[key]))
+                  return;
+                this.call("changedField", newItem.item, key, oldItem[key], newItem.item[key]);
+              });
+            }
+          }
+          if (newItem.index !== index && newItem.beforeItem?.id !== oldBeforeItem?.id) {
+            this.call("movedBefore", newItem.item, newItem.beforeItem);
+          }
+        } else {
+          this.call("removed", oldItem);
+        }
+      });
+    }
+    if (this.hasCallbacks(["added", "addedBefore"])) {
+      newItems.forEach((newItem, index) => {
+        const oldItem = oldItemsMap.get(newItem.id);
+        if (oldItem)
+          return;
+        this.call("added", newItem);
+        this.call("addedBefore", newItem, newItems[index + 1] || null);
+      });
+    }
+    this.previousItems = newItems;
+    Object.keys(this.callbacks).forEach((key) => {
+      const event = key;
+      const callbacks = this.callbacks[event];
+      this.callbacks[event] = callbacks.map((callback) => ({
+        ...callback,
+        options: {
+          ...callback.options,
+          isInitial: false
+        }
+      }));
+    });
+  }
+  /**
+   * Stops the observer by unbinding all events and cleaning up resources.
+   */
+  stop() {
+    this.unbindEvents();
+  }
+  /**
+   * Registers callbacks for specific events to observe changes in the collection.
+   * @param callbacks - An object containing the callbacks for various events (e.g., 'added', 'removed').
+   * @param skipInitial - A boolean indicating whether to skip invoking the callbacks for the initial state of the collection.
+   */
+  addCallbacks(callbacks, skipInitial = false) {
+    Object.keys(callbacks).forEach((key) => {
+      const typedKey = key;
+      this.callbacks[typedKey].push({
+        callback: callbacks[typedKey],
+        options: { skipInitial, isInitial: true }
+      });
+    });
+  }
+  /**
+   * Removes the specified callbacks for specific events, unregistering them from the observer.
+   * @param callbacks - An object containing the callbacks to be removed for various events.
+   */
+  removeCallbacks(callbacks) {
+    Object.keys(callbacks).forEach((key) => {
+      const typedKey = key;
+      const index = this.callbacks[typedKey].findIndex(({ callback }) => callback === callbacks[typedKey]);
+      this.callbacks[typedKey].splice(index, 1);
+    });
+  }
 }
-module.exports = match;
+module.exports = Observer;

package/dist/index.cjs19.js

@@ -1,42 +1,7 @@
 "use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-function clone(value) {
-  if (typeof value === "function")
-    throw new Error("Cloning functions is not supported");
-  if (value === null || typeof value !== "object")
-    return value;
-  if (value instanceof Date)
-    return new Date(value);
-  if (Array.isArray(value))
-    return value.map((item) => clone(item));
-  if (value instanceof Map) {
-    const result2 = /* @__PURE__ */ new Map();
-    value.forEach((currentValue, key) => {
-      result2.set(key, clone(currentValue));
-    });
-    return result2;
-  }
-  if (value instanceof Set) {
-    const result2 = /* @__PURE__ */ new Set();
-    value.forEach((currentValue) => {
-      result2.add(clone(currentValue));
-    });
-    return result2;
-  }
-  if (value instanceof RegExp)
-    return new RegExp(value);
-  const result = {};
-  for (const key in value) {
-    if (Object.hasOwnProperty.call(value, key)) {
-      result[key] = clone(value[key]);
-    }
-  }
-  return result;
+const mingo = require("mingo");
+function match(item, selector) {
+  const query = new mingo.Query(selector);
+  return query.test(item);
 }
-function deepClone(object) {
-  if (typeof structuredClone === "function")
-    return structuredClone(object);
-  return clone(object);
-}
-exports.clone = clone;
-exports.default = deepClone;
+module.exports = match;