@signaldb/core 1.2.4 → 1.3.0

package/dist/index23.mjs

@@ -1,11 +1,147 @@
-import { sort } from "fast-sort";
-import get from "./index27.mjs";
-function sortItems(items, sortFields) {
-  return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
-    const order = value === 1 ? "asc" : "desc";
-    return { [order]: (i) => get(i, key) };
-  }));
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import isEqual from "./index9.mjs";
+import uniqueBy from "./index29.mjs";
+class Observer {
+  /**
+   * 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) {
+    __publicField(this, "previousItems", []);
+    __publicField(this, "callbacks");
+    __publicField(this, "unbindEvents");
+    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 }) => {
+        var _a;
+        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 && ((_a = newItem.beforeItem) == null ? void 0 : _a.id) !== (oldBeforeItem == null ? void 0 : 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);
+    });
+  }
 }
 export {
-  sortItems as default
+  Observer as default
 };

package/dist/index24.mjs

@@ -1,28 +1,8 @@
-import get from "./index27.mjs";
-import set from "./index30.mjs";
-function project(item, fields) {
-  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
-  if (allFieldsDeactivated) {
-    const result2 = { ...item };
-    Object.keys(fields).forEach((key) => {
-      const fieldValue = get(item, key);
-      if (fieldValue === void 0)
-        return;
-      set(result2, key, void 0, true);
-    });
-    return result2;
-  }
-  const result = {};
-  Object.entries(fields).forEach(([key, value]) => {
-    const fieldValue = get(item, key);
-    if (fieldValue === void 0)
-      return;
-    if (fieldValue == null && value !== 1)
-      return;
-    set(result, key, value === 1 ? fieldValue : void 0);
-  });
-  return result;
+function intersection(...arrays) {
+  if (arrays.length === 0)
+    return [];
+  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
 }
 export {
-  project as default
+  intersection as default
 };

package/dist/index25.mjs

@@ -1,147 +1,19 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import isEqual from "./index10.mjs";
-import uniqueBy from "./index31.mjs";
-class Observer {
-  /**
-   * 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) {
-    __publicField(this, "previousItems", []);
-    __publicField(this, "callbacks");
-    __publicField(this, "unbindEvents");
-    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 }) => {
-        var _a;
-        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 && ((_a = newItem.beforeItem) == null ? void 0 : _a.id) !== (oldBeforeItem == null ? void 0 : 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);
-    });
-  }
+function get(value, path) {
+  const segments = path.split(/[.[\]]/g);
+  if (segments[0] === "")
+    segments.shift();
+  if (segments.at(-1) === "")
+    segments.pop();
+  let current = value;
+  for (const key of segments) {
+    if (current == null || key.trim() === "")
+      return;
+    current = current[key];
+  }
+  if (current === void 0)
+    return;
+  return current;
 }
 export {
-  Observer as default
+  get as default
 };

package/dist/index26.mjs

@@ -1,8 +1,30 @@
-function intersection(...arrays) {
-  if (arrays.length === 0)
-    return [];
-  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+import isFieldExpression from "./index27.mjs";
+import serializeValue from "./index16.mjs";
+function getMatchingKeys(field, selector) {
+  const result = { include: null, exclude: null };
+  const fieldSelector = selector[field];
+  if (fieldSelector instanceof RegExp)
+    return result;
+  if (fieldSelector == null)
+    return result;
+  if (isFieldExpression(fieldSelector)) {
+    if (fieldSelector.$ne != null) {
+      result.exclude = [serializeValue(fieldSelector.$ne)];
+      return result;
+    }
+    if (Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0) {
+      result.include = fieldSelector.$in.map(serializeValue);
+      return result;
+    }
+    if (Array.isArray(fieldSelector.$nin) && fieldSelector.$nin.length > 0) {
+      result.exclude = fieldSelector.$nin.map(serializeValue);
+      return result;
+    }
+    return { include: null, exclude: null };
+  }
+  result.include = [serializeValue(fieldSelector)];
+  return result;
 }
 export {
-  intersection as default
+  getMatchingKeys as default
 };

package/dist/index27.mjs

@@ -1,19 +1,43 @@
-function get(value, path) {
-  const segments = path.split(/[.[\]]/g);
-  if (segments[0] === "")
-    segments.shift();
-  if (segments.at(-1) === "")
-    segments.pop();
-  let current = value;
-  for (const key of segments) {
-    if (current == null || key.trim() === "")
-      return;
-    current = current[key];
+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;
   }
-  if (current === void 0)
-    return;
-  return current;
+  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;
 }
 export {
-  get as default
+  isFieldExpression as default
 };

package/dist/index28.mjs

@@ -1,29 +1,30 @@
-import isFieldExpression from "./index29.mjs";
-import serializeValue from "./index18.mjs";
-function getMatchingKeys(field, selector) {
-  const fieldSelector = selector[field];
-  if (fieldSelector instanceof RegExp)
-    return null;
-  if (fieldSelector != null) {
-    if (isFieldExpression(fieldSelector)) {
-      const is$in = isFieldExpression(fieldSelector) && Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0;
-      if (is$in) {
-        const optimizedSelector = {
-          ...selector,
-          [field]: { ...fieldSelector }
-        };
-        delete optimizedSelector[field].$in;
-        if (Object.keys(optimizedSelector[field]).length === 0) {
-          delete optimizedSelector[field];
-        }
-        return fieldSelector.$in.map(serializeValue);
+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 ? [] : {};
       }
-      return null;
+      apply(node[key]);
+    } else {
+      if (deleteIfUndefined && value === void 0) {
+        delete node[segments[0]];
+        return;
+      }
+      node[segments[0]] = value;
     }
-    return [serializeValue(fieldSelector)];
-  }
-  return null;
+  };
+  apply(object);
+  return object;
 }
 export {
-  getMatchingKeys as default
+  set as default
 };

package/dist/index29.mjs

@@ -1,43 +1,10 @@
-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;
+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 {
-  isFieldExpression as default
+  uniqueBy as default
 };