@signaldb/core 1.7.1 → 2.0.0-beta.1

package/dist/index.cjs30.js

@@ -0,0 +1,5 @@
+"use strict";
+function createIndexProvider(definition) {
+  return definition;
+}
+module.exports = createIndexProvider;

package/dist/index.cjs31.js

@@ -0,0 +1,7 @@
+"use strict";
+function intersection(...arrays) {
+  if (arrays.length === 0)
+    return [];
+  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+}
+module.exports = intersection;

package/dist/index.cjs32.js

@@ -0,0 +1,29 @@
+"use strict";
+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;
+}
+module.exports = set;

package/dist/index.cjs33.js

@@ -0,0 +1,42 @@
+"use strict";
+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;
+}
+module.exports = isFieldExpression;

package/dist/index.cjs4.js

@@ -1,167 +1,5 @@
 "use strict";
-const ReplicatedCollection = require("./index.cjs23.js");
-const createSignal = require("./index.cjs21.js");
-class AutoFetchCollection extends ReplicatedCollection.default {
-  activeObservers = /* @__PURE__ */ new Map();
-  observerTimeouts = /* @__PURE__ */ new Map();
-  purgeDelay;
-  idQueryCache = /* @__PURE__ */ new Map();
-  itemsCache = /* @__PURE__ */ new Map();
-  fetchQueryItems;
-  triggerReload = null;
-  reactivityAdapter = null;
-  loadingSignals = /* @__PURE__ */ new Map();
-  isFetchingSignal;
-  mergeItems;
-  /**
-   * @param options {Object} - Options for the collection.
-   * @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) {
-    let triggerRemoteChange;
-    super({
-      ...options,
-      pull: () => Promise.resolve({
-        items: [...this.itemsCache.values()].reduce((memo, items) => {
-          const newItems = [...memo];
-          items.forEach((item) => {
-            const index = newItems.findIndex((i) => i.id === item.id);
-            if (index === -1) {
-              newItems.push(item);
-              return;
-            }
-            newItems[index] = this.mergeItems(newItems[index], item);
-          });
-          return newItems;
-        }, [])
-      }),
-      registerRemoteChange: async (onChange) => {
-        triggerRemoteChange = onChange;
-      }
-    });
-    this.mergeItems = options.mergeItems ?? ((itemA, itemB) => ({ ...itemA, ...itemB }));
-    this.purgeDelay = options.purgeDelay ?? 1e4;
-    this.isFetchingSignal = createSignal(options.reactivity, false);
-    if (!triggerRemoteChange)
-      throw new Error("No triggerRemoteChange method found. Looks like your persistence adapter was not registered");
-    this.triggerReload = triggerRemoteChange;
-    this.reactivityAdapter = options.reactivity ?? null;
-    this.fetchQueryItems = options.fetchQueryItems;
-    this.on("observer.created", (selector) => this.handleObserverCreation(selector ?? {}));
-    this.on("observer.disposed", (selector) => setTimeout(() => this.handleObserverDisposal(selector ?? {}), 100));
-    if (options.registerRemoteChange) {
-      void options.registerRemoteChange(() => this.forceRefetch());
-    }
-  }
-  /**
-   * Registers a query manually that items should be fetched for it
-   * @param selector {Object} Selector of the query
-   */
-  registerQuery(selector) {
-    this.handleObserverCreation(selector);
-  }
-  /**
-   * Unregisters a query manually that items are not fetched anymore for it
-   * @param selector {Object} Selector of the query
-   */
-  unregisterQuery(selector) {
-    this.handleObserverDisposal(selector);
-  }
-  getKeyForSelector(selector) {
-    return JSON.stringify(selector);
-  }
-  async forceRefetch() {
-    return Promise.all([...this.activeObservers.values()].map(({ selector }) => this.fetchSelector(selector))).then(() => {
-    });
-  }
-  fetchSelector(selector) {
-    this.isFetchingSignal.set(true);
-    return this.fetchQueryItems(selector).then((response) => {
-      if (!response.items)
-        throw new Error("AutoFetchCollection currently only works with a full item response");
-      this.itemsCache.set(this.getKeyForSelector(selector), response.items);
-      response.items.forEach((item) => {
-        const queries = this.idQueryCache.get(item.id) ?? [];
-        queries.push(selector);
-        this.idQueryCache.set(item.id, queries);
-      });
-      this.setLoading(selector, true);
-      this.once("persistence.received", () => {
-        this.setLoading(selector, false);
-      });
-      if (!this.triggerReload)
-        throw new Error("No triggerReload method found. Looks like your persistence adapter was not registered");
-      void this.triggerReload();
-    }).catch((error) => {
-      this.emit("persistence.error", error);
-    }).finally(() => {
-      this.isFetchingSignal.set(false);
-    });
-  }
-  handleObserverCreation(selector) {
-    const activeObservers = this.activeObservers.get(this.getKeyForSelector(selector))?.count ?? 0;
-    this.activeObservers.set(this.getKeyForSelector(selector), {
-      selector,
-      count: activeObservers + 1
-    });
-    const timeout = this.observerTimeouts.get(this.getKeyForSelector(selector));
-    if (timeout)
-      clearTimeout(timeout);
-    if (activeObservers === 0)
-      void this.fetchSelector(selector);
-  }
-  handleObserverDisposal(selector) {
-    const currentObservers = this.activeObservers.get(this.getKeyForSelector(selector))?.count ?? 0;
-    const activeObservers = currentObservers - 1;
-    if (activeObservers > 0) {
-      this.activeObservers.set(this.getKeyForSelector(selector), {
-        selector,
-        count: activeObservers
-      });
-      return;
-    }
-    const timeout = this.observerTimeouts.get(this.getKeyForSelector(selector));
-    if (timeout)
-      clearTimeout(timeout);
-    const removeObserver = () => {
-      this.activeObservers.delete(this.getKeyForSelector(selector));
-      this.itemsCache.delete(this.getKeyForSelector(selector));
-      if (!this.triggerReload)
-        throw new Error("No triggerReload method found. Looks like your persistence adapter was not registered");
-      void this.triggerReload();
-    };
-    if (this.purgeDelay === 0) {
-      removeObserver();
-      return;
-    }
-    this.observerTimeouts.set(this.getKeyForSelector(selector), setTimeout(removeObserver, this.purgeDelay));
-  }
-  ensureSignal(selector) {
-    if (!this.reactivityAdapter)
-      throw new Error("No reactivity adapter found");
-    if (!this.loadingSignals.has(this.getKeyForSelector(selector))) {
-      this.loadingSignals.set(this.getKeyForSelector(selector), createSignal(this.reactivityAdapter, false));
-    }
-    return this.loadingSignals.get(this.getKeyForSelector(selector));
-  }
-  setLoading(selector, value) {
-    const signal = this.ensureSignal(selector);
-    signal.set(value);
-  }
-  /**
-   * Indicates wether a query is currently been loaded
-   * ⚡️ this function is reactive!
-   * @param selector {Object} Selector of the query
-   * @returns The loading state
-   */
-  isLoading(selector) {
-    const isPushing = this.isPushing();
-    if (!selector) {
-      return this.isFetchingSignal.get() || isPushing;
-    }
-    const signal = this.ensureSignal(selector);
-    return signal.get() || isPushing;
-  }
+function createStorageAdapter(definition) {
+  return definition;
 }
-module.exports = AutoFetchCollection;
+module.exports = createStorageAdapter;

package/dist/index.cjs5.js

@@ -1,68 +1,5 @@
 "use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const createPersistenceAdapter = require("./index.cjs8.js");
-function createTemporaryFallbackExecutor(firstResolvingPromiseFunction, secondResolvingPromiseFunction, options) {
-  const cacheTimeout = options?.cacheTimeout;
-  let isResolved = false;
-  let resolvedValue = null;
-  let timeout = null;
-  let secondaryPromise = null;
-  return (...args) => {
-    if (secondaryPromise == null) {
-      if (timeout) {
-        clearTimeout(timeout);
-        timeout = null;
-      }
-      secondaryPromise = secondResolvingPromiseFunction(...args).then((result) => {
-        {
-          timeout = setTimeout(() => {
-            isResolved = false;
-            resolvedValue = null;
-            secondaryPromise = null;
-          }, cacheTimeout);
-        }
-        isResolved = true;
-        resolvedValue = result;
-        if (options?.onResolve)
-          options.onResolve(resolvedValue);
-        return result;
-      });
-    } else if (isResolved) {
-      return secondaryPromise;
-    }
-    return firstResolvingPromiseFunction(...args);
-  };
+function createReactivityAdapter(definition) {
+  return definition;
 }
-function combinePersistenceAdapters(slowAdapter, fastAdapter) {
-  let handleChange = null;
-  const readExecutor = createTemporaryFallbackExecutor(() => fastAdapter.load(), () => slowAdapter.load(), {
-    cacheTimeout: 100,
-    onResolve: (result) => {
-      if (handleChange)
-        void handleChange();
-      void fastAdapter.save(result.items || [], {
-        added: result.changes?.added || [],
-        modified: result.changes?.modified || [],
-        removed: result.changes?.removed || []
-      });
-    }
-  });
-  return createPersistenceAdapter({
-    async register(onChange) {
-      handleChange = onChange;
-      await Promise.all([slowAdapter.register(onChange), fastAdapter.register(onChange)]);
-    },
-    async load() {
-      const promise = readExecutor();
-      return promise;
-    },
-    async save(items, changes) {
-      await Promise.all([
-        fastAdapter.save(items, changes),
-        slowAdapter.save(items, changes)
-      ]);
-    }
-  });
-}
-exports.createTemporaryFallbackExecutor = createTemporaryFallbackExecutor;
-exports.default = combinePersistenceAdapters;
+module.exports = createReactivityAdapter;

package/dist/index.cjs6.js

@@ -1,5 +1,29 @@
 "use strict";
-function createIndexProvider(definition) {
-  return definition;
+function isEqual(a, b) {
+  if (Object.is(a, b))
+    return true;
+  if (a instanceof RegExp && b instanceof RegExp)
+    return a.toString() === b.toString();
+  if (a instanceof Date && b instanceof Date)
+    return a.getTime() === b.getTime();
+  if (typeof a !== "object")
+    return false;
+  if (typeof b !== "object")
+    return false;
+  if (a === null)
+    return false;
+  if (b === null)
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  for (const key of aKeys) {
+    if (!bKeys.includes(key))
+      return false;
+    if (!isEqual(a[key], b[key]))
+      return false;
+  }
+  return true;
 }
-module.exports = createIndexProvider;
+module.exports = isEqual;

package/dist/index.cjs7.js

@@ -1,5 +1,12 @@
 "use strict";
-function createMemoryAdapter(definition) {
-  return definition;
+const mingo = require("mingo");
+const deepClone = require("./index.cjs19.js");
+function modify(item, modifier) {
+  const hasOperators = Object.keys(modifier).some((key) => key.startsWith("$"));
+  if (!hasOperators)
+    return modifier;
+  const clonedItem = deepClone.default(item);
+  mingo.update(clonedItem, modifier);
+  return clonedItem;
 }
-module.exports = createMemoryAdapter;
+module.exports = modify;

package/dist/index.cjs8.js

@@ -1,5 +1,5 @@
 "use strict";
-function createPersistenceAdapter(definition) {
-  return definition;
+function randomId() {
+  return Array.from({ length: 16 }, () => "abcdefghijklmnopqrstuvwxyz0123456789"[Math.floor(Math.random() * 36)]).join("");
 }
-module.exports = createPersistenceAdapter;
+module.exports = randomId;

package/dist/index.cjs9.js

@@ -1,5 +1,133 @@
 "use strict";
-function createReactivityAdapter(definition) {
-  return definition;
+class EventEmitter {
+  _maxListeners = 100;
+  /**
+   * We store a set of the listeners for each event.
+   */
+  _listenerStore = /* @__PURE__ */ new Map();
+  setMaxListeners(max) {
+    this._maxListeners = max;
+    return this;
+  }
+  /**
+   * Subscribe to an event with a listener function.
+   * @param eventName The event name (key of E).
+   * @param listener  A function that receives the emitted arguments.
+   * @returns         The emitter instance (for chaining).
+   */
+  on(eventName, listener) {
+    let listenersSet = this._listenerStore.get(eventName);
+    if (!listenersSet) {
+      listenersSet = /* @__PURE__ */ new Set();
+      this._listenerStore.set(eventName, listenersSet);
+    }
+    listenersSet.add(listener);
+    if (listenersSet.size > this._maxListeners) {
+      console.warn(`Possible EventEmitter memory leak detected. ${listenersSet.size} ${String(eventName)} listeners added. Use emitter.setMaxListeners() to increase limit.`);
+    }
+    return this;
+  }
+  /**
+   * Subscribe to an event with a listener function.
+   * @param eventName The event name (key of E).
+   * @param listener  A function that receives the emitted arguments.
+   * @returns         The emitter instance (for chaining).
+   */
+  addListener(eventName, listener) {
+    return this.on(eventName, listener);
+  }
+  /**
+   * Subscribe to an event, handling it only once. Automatically removes
+   * the listener after it fires the first time.
+   * @param eventName The event name (key of E).
+   * @param listener  A function that receives the emitted arguments.
+   * @returns         The emitter instance (for chaining).
+   */
+  once(eventName, listener) {
+    const onceWrapper = ((...args) => {
+      listener(...args);
+      this.off(eventName, onceWrapper);
+    });
+    return this.on(eventName, onceWrapper);
+  }
+  /**
+   * Unsubscribe a previously subscribed listener.
+   * @param eventName The event name (key of E).
+   * @param listener  The original function passed to `on` or `once`.
+   * @returns         The emitter instance (for chaining).
+   */
+  off(eventName, listener) {
+    const listenersSet = this._listenerStore.get(eventName);
+    if (!listenersSet)
+      return this;
+    listenersSet.delete(listener);
+    if (listenersSet.size === 0) {
+      this._listenerStore.delete(eventName);
+    }
+    return this;
+  }
+  /**
+   * Unsubscribe a previously subscribed listener.
+   * @param eventName The event name (key of E).
+   * @param listener  The original function passed to `on` or `once`.
+   * @returns         The emitter instance (for chaining).
+   */
+  removeListener(eventName, listener) {
+    return this.off(eventName, listener);
+  }
+  /**
+   * Emit (dispatch) an event with a variable number of arguments.
+   * @param eventName The event name (key of E).
+   * @param args      The arguments to pass to subscribed listeners.
+   */
+  emit(eventName, ...args) {
+    this.listeners(eventName).forEach((listener) => {
+      listener(...args);
+    });
+  }
+  /**
+   * Returns the array of listener functions currently registered for a given event.
+   * @param eventName The event name (key of E).
+   * @returns         An array of listener functions.
+   */
+  listeners(eventName) {
+    const listenersSet = this._listenerStore.get(eventName);
+    if (!listenersSet)
+      return [];
+    return [...listenersSet.values()];
+  }
+  /**
+   * Returns the number of listeners for a given event.
+   * @param eventName The event name (key of E).
+   * @returns         The number of listeners.
+   */
+  listenerCount(eventName) {
+    const listenersSet = this._listenerStore.get(eventName);
+    return listenersSet ? listenersSet.size : 0;
+  }
+  /**
+   * Removes all listeners for a given event, or all events if none is specified.
+   * @param eventName Optional. If omitted, clears all events’ listeners.
+   * @returns         The emitter instance (for chaining).
+   */
+  removeAllListeners(eventName) {
+    if (eventName === void 0) {
+      for (const [eventName_, listenersSet] of this._listenerStore.entries()) {
+        for (const listener of listenersSet.values()) {
+          this.off(eventName_, listener);
+        }
+      }
+      this._listenerStore.clear();
+    } else {
+      const listenersSet = this._listenerStore.get(eventName);
+      if (listenersSet) {
+        for (const listener of listenersSet.values()) {
+          this.off(eventName, listener);
+        }
+        this._listenerStore.delete(eventName);
+      }
+    }
+    return this;
+  }
 }
-module.exports = createReactivityAdapter;
+module.exports = EventEmitter;

package/dist/index.d.ts

@@ -1,18 +1,21 @@
 export type { default as ReactivityAdapter } from './types/ReactivityAdapter';
-export type { default as MemoryAdapter } from './types/MemoryAdapter';
-export type { default as PersistenceAdapter, Changeset, LoadResponse, } from './types/PersistenceAdapter';
+export type { default as StorageAdapter, Changeset, } from './types/StorageAdapter';
 export type { default as Selector } from './types/Selector';
 export type { default as Modifier } from './types/Modifier';
 export type { BaseItem, ObserveCallbacks, CursorOptions, Transform, SortSpecifier, FieldSpecifier, FindOptions, CollectionOptions, } from './Collection';
+export type { default as DataAdapter } from './DataAdapter';
 export { default as Cursor } from './Collection/Cursor';
-export { default as Collection, createIndex } from './Collection';
-export { default as AutoFetchCollection } from './AutoFetchCollection';
-export { default as combinePersistenceAdapters } from './persistence/combinePersistenceAdapters';
-export { default as createIndexProvider } from './createIndexProvider';
-export { default as createMemoryAdapter } from './createMemoryAdapter';
-export { default as createPersistenceAdapter } from './persistence/createPersistenceAdapter';
+export { default as Collection } from './Collection';
+export { default as createStorageAdapter } from './createStorageAdapter';
 export { default as createReactivityAdapter } from './createReactivityAdapter';
 export { default as isEqual } from './utils/isEqual';
 export { default as modify } from './utils/modify';
 export { default as randomId } from './utils/randomId';
 export { default as EventEmitter } from './utils/EventEmitter';
+export { default as get } from './utils/get';
+export { default as serializeValue } from './utils/serializeValue';
+export { default as DefaultDataAdapter } from './DefaultDataAdapter';
+export { default as AsyncDataAdapter } from './AsyncDataAdapter';
+export { default as WorkerDataAdapter } from './WorkerDataAdapter';
+export { default as WorkerDataAdapterHost } from './WorkerDataAdapterHost';
+export { default as AutoFetchDataAdapter } from './AutoFetchDataAdapter';

package/dist/index.mjs

@@ -11,18 +11,22 @@ import { default as default11 } from "./index11.mjs";
 import { default as default12 } from "./index12.mjs";
 import { default as default13 } from "./index13.mjs";
 import { default as default14 } from "./index14.mjs";
+import { default as default15 } from "./index15.mjs";
+import { default as default16 } from "./index16.mjs";
 export {
-  default4 as AutoFetchCollection,
+  default13 as AsyncDataAdapter,
+  default16 as AutoFetchDataAdapter,
   default3 as Collection,
   default2 as Cursor,
-  default13 as EventEmitter,
-  default5 as combinePersistenceAdapters,
-  default14 as createIndex,
-  default6 as createIndexProvider,
-  default7 as createMemoryAdapter,
-  default8 as createPersistenceAdapter,
-  default9 as createReactivityAdapter,
-  default10 as isEqual,
-  default11 as modify,
-  default12 as randomId
+  default12 as DefaultDataAdapter,
+  default9 as EventEmitter,
+  default14 as WorkerDataAdapter,
+  default15 as WorkerDataAdapterHost,
+  default5 as createReactivityAdapter,
+  default4 as createStorageAdapter,
+  default10 as get,
+  default6 as isEqual,
+  default7 as modify,
+  default8 as randomId,
+  default11 as serializeValue
 };

package/dist/index10.mjs

@@ -1,30 +1,19 @@
-function isEqual(a, b) {
-  if (Object.is(a, b))
-    return true;
-  if (a instanceof RegExp && b instanceof RegExp)
-    return a.toString() === b.toString();
-  if (a instanceof Date && b instanceof Date)
-    return a.getTime() === b.getTime();
-  if (typeof a !== "object")
-    return false;
-  if (typeof b !== "object")
-    return false;
-  if (a === null)
-    return false;
-  if (b === null)
-    return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length)
-    return false;
-  for (const key of aKeys) {
-    if (!bKeys.includes(key))
-      return false;
-    if (!isEqual(a[key], b[key]))
-      return false;
+function get(value, path) {
+  const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
+  if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) {
+    return;
   }
-  return true;
+  const segments = normalized.split(".");
+  let current = value;
+  for (const key of segments) {
+    if (current == null)
+      return;
+    current = current[key];
+  }
+  if (current === void 0)
+    return;
+  return current;
 }
 export {
-  isEqual as default
+  get as default
 };

package/dist/index11.mjs

@@ -1,13 +1,16 @@
-import { update } from "mingo";
-import deepClone from "./index19.mjs";
-function modify(item, modifier) {
-  const hasOperators = Object.keys(modifier).some((key) => key.startsWith("$"));
-  if (!hasOperators)
-    return modifier;
-  const clonedItem = deepClone(item);
-  update(clonedItem, modifier);
-  return clonedItem;
+function serializeValue(value) {
+  if (value == null)
+    return null;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number")
+    return value.toString();
+  if (typeof value === "boolean")
+    return value.toString();
+  if (value instanceof Date)
+    return value.toISOString();
+  return JSON.stringify(value);
 }
 export {
-  modify as default
+  serializeValue as default
 };