@signaldb/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/index3.mjs

@@ -1,557 +1,19 @@
-import EventEmitter from "./index9.mjs";
-import createSignal from "./index18.mjs";
-import randomId from "./index8.mjs";
-import DefaultDataAdapter from "./index12.mjs";
-import modify from "./index7.mjs";
-import deepClone from "./index19.mjs";
-import queryId from "./index20.mjs";
-import Cursor from "./index2.mjs";
-class Collection extends EventEmitter {
-  static collections = [];
-  static debugMode = false;
-  static batchOperationInProgress = false;
-  static fieldTracking = false;
-  static onCreationCallbacks = [];
-  static onDisposeCallbacks = [];
-  static getCollections() {
-    return Collection.collections;
-  }
-  static onCreation(callback) {
-    Collection.onCreationCallbacks.push(callback);
-  }
-  static onDispose(callback) {
-    Collection.onDisposeCallbacks.push(callback);
-  }
-  /**
-   * Enables debug mode for all collections.
-   */
-  static enableDebugMode = () => {
-    Collection.debugMode = true;
-    Collection.collections.forEach((collection) => {
-      collection.setDebugMode(true);
-    });
-  };
-  /**
-   * Enables field tracking for all collections.
-   * @param enable - A boolean indicating whether to enable field tracking.
-   */
-  static setFieldTracking = (enable) => {
-    Collection.fieldTracking = enable;
-    Collection.collections.forEach((collection) => {
-      collection.setFieldTracking(enable);
-    });
-  };
-  static batch(callback) {
-    Collection.batchOperationInProgress = true;
-    const execute = () => Collection.collections.reduce((memo, collection) => () => {
-      return collection.batch(memo);
-    }, callback)();
-    const maybePromise = execute();
-    const afterBatch = () => {
-      Collection.batchOperationInProgress = false;
-    };
-    if (maybePromise && typeof maybePromise.then === "function") {
-      return maybePromise.then(() => afterBatch());
-    } else {
-      afterBatch();
-    }
-  }
-  name;
-  backend;
-  options;
-  isPullingSignal;
-  isPushingSignal;
-  readySignal;
-  debugMode;
-  batchOperationInProgress = false;
-  isDisposed = false;
-  postBatchCallbacks = /* @__PURE__ */ new Set();
-  fieldTracking = false;
-  queryListenersMap = /* @__PURE__ */ new Map();
-  constructor(nameOrOptions, maybeDataAdapter, maybeOptions) {
-    super();
-    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name || `${this.constructor.name}-${randomId()}`;
-    const options = typeof nameOrOptions === "string" ? maybeOptions || {} : nameOrOptions || {};
-    const persistence = options.persistence;
-    const dataAdapter = maybeDataAdapter || new DefaultDataAdapter({
-      ...persistence ? { storage: () => persistence } : {}
-    });
-    Collection.collections.push(this);
-    this.name = name;
-    this.options = { ...options };
-    this.fieldTracking = this.options.fieldTracking ?? Collection.fieldTracking;
-    this.debugMode = this.options.enableDebugMode ?? Collection.debugMode;
-    this.isPullingSignal = createSignal(this.options.reactivity, false);
-    this.isPushingSignal = createSignal(this.options.reactivity, false);
-    this.readySignal = createSignal(this.options.reactivity, false);
-    this.backend = dataAdapter.createCollectionBackend(this, this.options.indices ?? []);
-    void this.backend.isReady().then(() => {
-      this.readySignal.set(true);
-    }).catch(() => {
-    });
-    Collection.onCreationCallbacks.forEach((callback) => callback(this));
-  }
-  isBatchOperationInProgress() {
-    return Collection.batchOperationInProgress || this.batchOperationInProgress;
-  }
-  /**
-   * Checks whether the collection is currently performing a pull operation
-   * ⚡️ this function is reactive!
-   * (loading data from the persistence adapter).
-   * @returns A boolean indicating if the collection is in the process of pulling data.
-   */
-  isPulling() {
-    return this.isPullingSignal.get() ?? false;
-  }
-  /**
-   * Checks whether the collection is currently performing a push operation
-   * ⚡️ this function is reactive!
-   * (saving data to the persistence adapter).
-   * @returns A boolean indicating if the collection is in the process of pushing data.
-   */
-  isPushing() {
-    return this.isPushingSignal.get() ?? false;
-  }
-  /**
-   * Checks whether the collection is currently performing either a pull or push operation,
-   * ⚡️ this function is reactive!
-   * indicating that it is loading or saving data.
-   * @returns A boolean indicating if the collection is in the process of loading or saving data.
-   */
-  isLoading() {
-    const isPulling = this.isPulling();
-    const isPushing = this.isPushing();
-    return isPulling || isPushing;
-  }
-  /**
-   * Retrieves the current debug mode status of the collection.
-   * @returns A boolean indicating whether debug mode is enabled for the collection.
-   */
-  getDebugMode() {
-    return this.debugMode;
-  }
-  /**
-   * Enables or disables debug mode for the collection.
-   * When debug mode is enabled, additional debugging information and events are emitted.
-   * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) debug mode.
-   */
-  setDebugMode(enable) {
-    this.debugMode = enable;
-  }
-  /**
-   * Enables or disables field tracking for the collection.
-   * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) field tracking.
-   */
-  setFieldTracking(enable) {
-    this.fieldTracking = enable;
-  }
-  /**
-   * Resolves when the persistence adapter finished initializing
-   * and the collection is ready to be used.
-   * @returns A promise that resolves when the collection is ready.
-   * @example
-   * ```ts
-   * const collection = new Collection({
-   *   persistence: // ...
-   * })
-   * await collection.isReady()
-   *
-   * collection.insert({ name: 'Item 1' })
-   */
-  async ready() {
-    return this.backend.isReady();
-  }
-  /**
-   * Checks if the collection is ready.
-   * ⚡️ this function is reactive!
-   * @returns A boolean indicating whether the collection is ready.
-   */
-  isReady() {
-    return this.readySignal.get() ?? false;
-  }
-  profile(fn, measureFunction) {
-    if (!this.debugMode)
-      return fn();
-    const startTime = performance.now();
-    const handleProfileEnd = (result) => {
-      const endTime = performance.now();
-      measureFunction(endTime - startTime);
-      return result;
-    };
-    const maybePromise = fn();
-    return maybePromise instanceof Promise ? maybePromise.then(handleProfileEnd) : handleProfileEnd(maybePromise);
-  }
-  executeInDebugMode(fn) {
-    if (!this.debugMode)
-      return;
-    const callstack = new Error().stack || "";
-    fn(callstack);
-  }
-  transform(item) {
-    if (!this.options.transform)
-      return item;
-    return this.options.transform(item);
-  }
-  transformAll(items, fields) {
-    if (!this.options.transformAll)
-      return items;
-    return this.options.transformAll(deepClone(items), fields);
-  }
-  getItem(selector, options) {
-    const itemsOrPromise = this.getItems(selector, { ...options, limit: 1 });
-    if (itemsOrPromise instanceof Promise) {
-      return itemsOrPromise.then((items) => {
-        return items[0] || void 0;
-      });
-    }
-    return itemsOrPromise[0];
-  }
-  getItems(selector, options) {
-    this.emit("getItems", selector);
-    return this.profile(() => {
-      if (!options?.async)
-        return this.backend.getQueryResult(selector, options);
-      this.isPullingSignal.set(true);
-      return this.backend.executeQuery(selector, options).finally(() => {
-        this.isPullingSignal.set(false);
-      });
-    }, (measuredTime) => this.executeInDebugMode((callstack) => this.emit("_debug.getItems", callstack, selector, measuredTime)));
-  }
-  async withPushState(asyncFunction) {
-    this.isPushingSignal.set(true);
-    try {
-      return await asyncFunction();
-    } finally {
-      this.isPushingSignal.set(false);
-    }
-  }
-  queryListeners(query, listeners) {
-    const id = queryId(query.selector, query.options);
-    if (listeners != null) {
-      return this.queryListenersMap.set(id, listeners);
-    }
-    return this.queryListenersMap.get(id) ?? 0;
-  }
-  /**
-   * Disposes the collection, unregisters persistence adapters, clears memory, and
-   * cleans up all resources used by the collection.
-   * @returns A promise that resolves when the collection is disposed.
-   */
-  async dispose() {
-    await this.backend.dispose();
-    this.isDisposed = true;
-    this.removeAllListeners();
-    Collection.collections = Collection.collections.filter((collection) => collection !== this);
-    Collection.onDisposeCallbacks.forEach((callback) => callback(this));
-  }
-  /**
-   * Finds multiple items in the collection based on a selector and optional options.
-   * Returns a cursor for reactive data queries.
-   * @template O - The options type for the find operation.
-   * @param [selector] - The criteria to select items.
-   * @param [options] - Options for the find operation, such as limit and sort.
-   * @returns A cursor to fetch and observe the matching items.
-   */
-  find(selector = {}, options) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (selector !== void 0 && (!selector || typeof selector !== "object"))
-      throw new Error("Invalid selector");
-    const getTransformedItems = () => {
-      const itemsOrPromise = this.getItems(selector, options || {});
-      if (itemsOrPromise instanceof Promise) {
-        return itemsOrPromise.then((items2) => {
-          return this.transformAll(items2, options?.fields);
-        });
-      }
-      const items = itemsOrPromise;
-      return this.transformAll(items, options?.fields);
-    };
-    const cursor = new Cursor(getTransformedItems, {
-      reactive: this.options.reactivity,
-      fieldTracking: this.fieldTracking,
-      ...options,
-      transform: this.transform.bind(this),
-      bindEvents: (requery) => {
-        const handleRequery = () => {
-          if (this.batchOperationInProgress) {
-            this.postBatchCallbacks.add(requery);
-            return;
-          }
-          requery();
-        };
-        const listeners = this.queryListeners({ selector, options });
-        if (listeners === 0)
-          this.backend.registerQuery(selector, options || {});
-        this.queryListeners({ selector, options }, listeners + 1);
-        const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options || {}, (state) => {
-          if (state !== "complete")
-            return;
-          handleRequery();
-        });
-        this.emit("observer.created", selector, options);
-        return () => {
-          setTimeout(() => {
-            const newListeners = Math.max(0, this.queryListeners({ selector, options }) - 1);
-            if (newListeners === 0)
-              this.backend.unregisterQuery(selector, options || {});
-            this.queryListeners({ selector, options }, newListeners);
-            queryStateChangeCleanup();
-            this.emit("observer.disposed", selector, options);
-          }, 0);
-        };
-      }
-    });
-    this.emit("find", selector, options, cursor);
-    this.executeInDebugMode((callstack) => this.emit("_debug.find", callstack, selector, options, cursor));
-    return cursor;
-  }
-  /**
-   * Finds a single item in the collection based on a selector and optional options.
-   * ⚡️ this function is reactive!
-   * Returns the found item or undefined if no item matches.
-   * @template Async - Whether to perform the operation asynchronously.
-   * @template O - The options type for the find operation.
-   * @param selector - The criteria to select the item.
-   * @param [options] - Options for the find operation, such as projection.
-   * @returns The found item or `undefined`.
-   */
-  findOne(selector, options) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    const cursor = this.find(selector, {
-      limit: 1,
-      ...options
-    });
-    const handleItems = (items) => {
-      const returnValue = items[0] || void 0;
-      this.emit("findOne", selector, options, returnValue);
-      this.executeInDebugMode((callstack) => this.emit("_debug.findOne", callstack, selector, options, returnValue));
-      return returnValue;
-    };
-    const maybePromise = cursor.fetch();
-    return maybePromise instanceof Promise ? maybePromise.then(handleItems) : handleItems(maybePromise);
-  }
-  batch(callback) {
-    if (this.batchOperationInProgress)
-      return callback();
-    this.batchOperationInProgress = true;
-    const maybePromise = callback();
-    const afterBatch = () => {
-      this.batchOperationInProgress = false;
-      this.postBatchCallbacks.forEach((callback_) => callback_());
-      this.postBatchCallbacks.clear();
-    };
-    if (maybePromise && typeof maybePromise.then === "function") {
-      return maybePromise.then(() => afterBatch());
-    } else {
-      afterBatch();
-    }
-  }
-  onPostBatch(callback) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (this.batchOperationInProgress) {
-      this.postBatchCallbacks.add(callback);
-      return;
-    }
-    return callback();
-  }
-  /**
-   * Inserts a single item into the collection. Generates a unique ID if not provided.
-   * @param item - The item to insert.
-   * @returns The ID of the inserted item.
-   * @throws {Error} If the collection is disposed or the item has an invalid ID.
-   */
-  async insert(item) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!item)
-      throw new Error("Invalid item");
-    const primaryKeyGenerator = this.options.primaryKeyGenerator ?? randomId;
-    const itemWithId = {
-      id: primaryKeyGenerator(item),
-      ...item
-    };
-    this.emit("validate", itemWithId);
-    const newItem = await this.withPushState(() => this.backend.insert(itemWithId));
-    this.emit("added", newItem);
-    this.emit("insert", newItem);
-    this.executeInDebugMode((callstack) => this.emit("_debug.insert", callstack, newItem));
-    return newItem.id;
-  }
-  /**
-   * Inserts multiple items into the collection. Generates unique IDs for items if not provided.
-   * @param items - The items to insert.
-   * @returns An array of IDs of the inserted items.
-   * @throws {Error} If the collection is disposed or the items are invalid.
-   */
-  async insertMany(items) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!items)
-      throw new Error("Invalid items");
-    if (items.length === 0)
-      return [];
-    const ids = [];
-    await this.batch(async () => {
-      await Promise.all(items.map(async (item) => {
-        ids.push(await this.insert(item));
-      }));
-    });
-    return ids;
-  }
-  /**
-   * Updates a single item in the collection that matches the given selector.
-   * @param selector - The criteria to select the item to update.
-   * @param modifier - The modifications to apply to the item.
-   * @param [options] - Optional settings for the update operation.
-   * @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
-   * @returns The number of items updated (0 or 1).
-   * @throws {Error} If the collection is disposed or invalid arguments are provided.
-   */
-  async updateOne(selector, modifier, options) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!selector)
-      throw new Error("Invalid selector");
-    if (!modifier)
-      throw new Error("Invalid modifier");
-    const { $setOnInsert, ...restModifier } = modifier;
-    const item = await this.getItem(selector, { async: true });
-    if (item == null) {
-      if (options?.upsert) {
-        const newItem = modify({}, {
-          ...restModifier,
-          $set: {
-            ...$setOnInsert,
-            ...restModifier.$set
-          }
-        });
-        await this.insert(newItem);
-        return 1;
-      }
-      return 0;
-    }
-    const modifiedItem = modify(deepClone(item), restModifier);
-    this.emit("validate", modifiedItem);
-    const changes = await this.withPushState(() => this.backend.updateOne(selector, modifier));
-    this.emit("changed", modifiedItem, restModifier);
-    this.emit("updateOne", selector, modifier);
-    this.executeInDebugMode((callstack) => this.emit("_debug.updateOne", callstack, selector, modifier));
-    return changes.length;
-  }
-  /**
-   * Updates multiple items in the collection that match the given selector.
-   * @param selector - The criteria to select the items to update.
-   * @param modifier - The modifications to apply to the items.
-   * @param [options] - Optional settings for the update operation.
-   * @param [options.upsert] - If `true`, creates new items if no items match the selector.
-   * @returns The number of items updated.
-   * @throws {Error} If the collection is disposed or invalid arguments are provided.
-   */
-  async updateMany(selector, modifier, options) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!selector)
-      throw new Error("Invalid selector");
-    if (!modifier)
-      throw new Error("Invalid modifier");
-    const { $setOnInsert, ...restModifier } = modifier;
-    const items = await this.getItems(selector, { async: true });
-    if (items.length === 0) {
-      if (options?.upsert) {
-        const newItem = modify({}, {
-          ...restModifier,
-          $set: {
-            ...$setOnInsert,
-            ...restModifier.$set
-          }
-        });
-        await this.insert(newItem);
-        return 1;
-      }
-      return 0;
-    }
-    items.forEach((item) => {
-      const modifiedItem = modify(deepClone(item), restModifier);
-      this.emit("validate", modifiedItem);
-    });
-    const changes = await this.withPushState(() => this.backend.updateMany(selector, modifier));
-    changes.forEach((item) => {
-      this.emit("changed", item, restModifier);
-    });
-    this.emit("updateMany", selector, modifier);
-    this.executeInDebugMode((callstack) => this.emit("_debug.updateMany", callstack, selector, modifier));
-    return changes.length;
-  }
-  /**
-   * Replaces a single item in the collection that matches the given selector.
-   * @param selector - The criteria to select the item to replace.
-   * @param replacement - The item to replace the selected item with.
-   * @param [options] - Optional settings for the replace operation.
-   * @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
-   * @returns The number of items replaced (0 or 1).
-   * @throws {Error} If the collection is disposed or invalid arguments are provided.
-   */
-  async replaceOne(selector, replacement, options) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!selector)
-      throw new Error("Invalid selector");
-    const item = await this.getItem(selector, { async: true });
-    if (item == null) {
-      if (options?.upsert) {
-        await this.insert(replacement);
-        return 1;
-      }
-      return 0;
-    }
-    const modifiedItem = { id: item.id, ...replacement };
-    this.emit("validate", modifiedItem);
-    const changes = await this.withPushState(() => this.backend.replaceOne(selector, replacement));
-    this.emit("changed", modifiedItem, replacement);
-    this.emit("replaceOne", selector, replacement);
-    this.executeInDebugMode((callstack) => this.emit("_debug.replaceOne", callstack, selector, replacement));
-    return changes.length;
-  }
-  /**
-   * Removes a single item from the collection that matches the given selector.
-   * @param selector - The criteria to select the item to remove.
-   * @returns The number of items removed (0 or 1).
-   * @throws {Error} If the collection is disposed or invalid arguments are provided.
-   */
-  async removeOne(selector) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!selector)
-      throw new Error("Invalid selector");
-    const removedItems = await this.withPushState(() => this.backend.removeOne(selector));
-    this.emit("removed", removedItems[0]);
-    this.emit("removeOne", selector);
-    this.executeInDebugMode((callstack) => this.emit("_debug.removeOne", callstack, selector));
-    return removedItems.length;
-  }
-  /**
-   * Removes multiple items from the collection that match the given selector.
-   * @param selector - The criteria to select the items to remove.
-   * @returns The number of items removed.
-   * @throws {Error} If the collection is disposed or invalid arguments are provided.
-   */
-  async removeMany(selector) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!selector)
-      throw new Error("Invalid selector");
-    const removedItems = await this.withPushState(() => this.backend.removeMany(selector));
-    removedItems.forEach((item) => {
-      this.emit("removed", item);
-    });
-    this.emit("removeMany", selector);
-    this.executeInDebugMode((callstack) => this.emit("_debug.removeMany", callstack, selector));
-    return removedItems.length;
-  }
+//#region src/utils/uniqueBy.ts
+/**
+* Filters an array to ensure unique values based on a specified key or transformation function.
+* @template T - The type of the elements in the array.
+* @param array - The array to filter for unique values.
+* @param fn - A key or transformation function to determine uniqueness.
+*   - If a key is provided, it will use the corresponding property of each element for uniqueness.
+*   - If a function is provided, it will use the return value of the function applied to each element for uniqueness.
+* @returns A new array containing only unique elements based on the specified key or transformation.
+*/
+function uniqueBy(array, fn) {
+	const set = /* @__PURE__ */ new Set();
+	return array.filter((element) => {
+		const value = typeof fn === "function" ? fn(element) : element[fn];
+		return !set.has(value) && set.add(value);
+	});
 }
-export {
-  Collection as default
-};
+//#endregion
+export { uniqueBy as default };

package/dist/index30.cjs.js

@@ -0,0 +1,11 @@
+//#region src/createStorageAdapter.ts
+/**
+* Creates an StorageAdapter based on the given definition.
+* @param definition - The definition of the StorageAdapter.
+* @returns The created StorageAdapter.
+*/
+function createStorageAdapter(definition) {
+	return definition;
+}
+//#endregion
+exports.default = createStorageAdapter;

package/dist/index30.mjs

@@ -1,43 +1,11 @@
-const expressionKeys = /* @__PURE__ */ new Set([
-  "$eq",
-  "$gt",
-  "$gte",
-  "$lt",
-  "$lte",
-  "$in",
-  "$nin",
-  "$ne",
-  "$exists",
-  "$not",
-  "$expr",
-  "$jsonSchema",
-  "$mod",
-  "$regex",
-  "$options",
-  "$text",
-  "$where",
-  "$all",
-  "$elemMatch",
-  "$size",
-  "$bitsAllClear",
-  "$bitsAllSet",
-  "$bitsAnyClear",
-  "$bitsAnySet"
-]);
-function isFieldExpression(expression) {
-  if (typeof expression !== "object" || expression == null) {
-    return false;
-  }
-  const keys = Object.keys(expression);
-  if (keys.length === 0) {
-    return false;
-  }
-  const hasInvalidKeys = keys.some((key) => !expressionKeys.has(key));
-  if (hasInvalidKeys)
-    return false;
-  const hasValidKeys = keys.every((key) => expressionKeys.has(key));
-  return hasValidKeys;
+//#region src/createStorageAdapter.ts
+/**
+* Creates an StorageAdapter based on the given definition.
+* @param definition - The definition of the StorageAdapter.
+* @returns The created StorageAdapter.
+*/
+function createStorageAdapter(definition) {
+	return definition;
 }
-export {
-  isFieldExpression as default
-};
+//#endregion
+export { createStorageAdapter as default };

package/dist/index31.cjs.js

@@ -0,0 +1,11 @@
+//#region src/createReactivityAdapter.ts
+/**
+* Creates an ReactivityAdapter based on the given definition.
+* @param definition - The definition of the ReactivityAdapter.
+* @returns The created ReactivityAdapter.
+*/
+function createReactivityAdapter(definition) {
+	return definition;
+}
+//#endregion
+exports.default = createReactivityAdapter;

package/dist/index31.mjs

@@ -1,30 +1,11 @@
-function set(object, path, value, deleteIfUndefined = false) {
-  if (object == null)
-    return object;
-  const segments = path.split(/[.[\]]/g);
-  if (segments[0] === "")
-    segments.shift();
-  if (segments.at(-1) === "")
-    segments.pop();
-  const apply = (node) => {
-    if (segments.length > 1) {
-      const key = segments.shift();
-      const nextIsNumber = !Number.isNaN(Number.parseInt(segments[0], 10));
-      if (node[key] === void 0) {
-        node[key] = nextIsNumber ? [] : {};
-      }
-      apply(node[key]);
-    } else {
-      if (deleteIfUndefined && value === void 0) {
-        delete node[segments[0]];
-        return;
-      }
-      node[segments[0]] = value;
-    }
-  };
-  apply(object);
-  return object;
+//#region src/createReactivityAdapter.ts
+/**
+* Creates an ReactivityAdapter based on the given definition.
+* @param definition - The definition of the ReactivityAdapter.
+* @returns The created ReactivityAdapter.
+*/
+function createReactivityAdapter(definition) {
+	return definition;
 }
-export {
-  set as default
-};
+//#endregion
+export { createReactivityAdapter as default };