@signaldb/core 1.5.4 → 1.6.0

package/dist/index.cjs4.js

@@ -1,69 +1,172 @@
 "use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const createPersistenceAdapter = require("./index.cjs7.js");
-function createTemporaryFallbackExecutor(firstResolvingPromiseFunction, secondResolvingPromiseFunction, options) {
-  const cacheTimeout = options == null ? void 0 : 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;
+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);
+const ReplicatedCollection = require("./index.cjs23.js");
+const createSignal = require("./index.cjs21.js");
+class AutoFetchCollection extends ReplicatedCollection.default {
+  /**
+   * @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;
       }
-      secondaryPromise = secondResolvingPromiseFunction(...args).then((result) => {
-        {
-          timeout = setTimeout(() => {
-            isResolved = false;
-            resolvedValue = null;
-            secondaryPromise = null;
-          }, cacheTimeout);
-        }
-        isResolved = true;
-        resolvedValue = result;
-        if (options == null ? void 0 : options.onResolve)
-          options.onResolve(resolvedValue);
-        return result;
-      });
-    } else if (isResolved) {
-      return secondaryPromise;
+    });
+    __publicField(this, "activeObservers", /* @__PURE__ */ new Map());
+    __publicField(this, "observerTimeouts", /* @__PURE__ */ new Map());
+    __publicField(this, "purgeDelay");
+    __publicField(this, "idQueryCache", /* @__PURE__ */ new Map());
+    __publicField(this, "itemsCache", /* @__PURE__ */ new Map());
+    __publicField(this, "fetchQueryItems");
+    __publicField(this, "triggerReload", null);
+    __publicField(this, "reactivityAdapter", null);
+    __publicField(this, "loadingSignals", /* @__PURE__ */ new Map());
+    __publicField(this, "isFetchingSignal");
+    __publicField(this, "mergeItems");
+    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());
     }
-    return firstResolvingPromiseFunction(...args);
-  };
-}
-function combinePersistenceAdapters(slowAdapter, fastAdapter) {
-  let handleChange = null;
-  const readExecutor = createTemporaryFallbackExecutor(() => fastAdapter.load(), () => slowAdapter.load(), {
-    cacheTimeout: 100,
-    onResolve: (result) => {
-      var _a, _b, _c;
-      if (handleChange)
-        void handleChange();
-      void fastAdapter.save(result.items || [], {
-        added: ((_a = result.changes) == null ? void 0 : _a.added) || [],
-        modified: ((_b = result.changes) == null ? void 0 : _b.modified) || [],
-        removed: ((_c = result.changes) == null ? void 0 : _c.removed) || []
+  }
+  /**
+   * 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) {
+    var _a;
+    const activeObservers = ((_a = this.activeObservers.get(this.getKeyForSelector(selector))) == null ? void 0 : _a.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) {
+    var _a;
+    const currentObservers = ((_a = this.activeObservers.get(this.getKeyForSelector(selector))) == null ? void 0 : _a.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 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)
-      ]);
+    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;
+  }
 }
-exports.createTemporaryFallbackExecutor = createTemporaryFallbackExecutor;
-exports.default = combinePersistenceAdapters;
+module.exports = AutoFetchCollection;

package/dist/index.cjs5.js

@@ -1,5 +1,69 @@
 "use strict";
-function createIndexProvider(definition) {
-  return definition;
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const createPersistenceAdapter = require("./index.cjs8.js");
+function createTemporaryFallbackExecutor(firstResolvingPromiseFunction, secondResolvingPromiseFunction, options) {
+  const cacheTimeout = options == null ? void 0 : 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 == null ? void 0 : options.onResolve)
+          options.onResolve(resolvedValue);
+        return result;
+      });
+    } else if (isResolved) {
+      return secondaryPromise;
+    }
+    return firstResolvingPromiseFunction(...args);
+  };
 }
-module.exports = createIndexProvider;
+function combinePersistenceAdapters(slowAdapter, fastAdapter) {
+  let handleChange = null;
+  const readExecutor = createTemporaryFallbackExecutor(() => fastAdapter.load(), () => slowAdapter.load(), {
+    cacheTimeout: 100,
+    onResolve: (result) => {
+      var _a, _b, _c;
+      if (handleChange)
+        void handleChange();
+      void fastAdapter.save(result.items || [], {
+        added: ((_a = result.changes) == null ? void 0 : _a.added) || [],
+        modified: ((_b = result.changes) == null ? void 0 : _b.modified) || [],
+        removed: ((_c = result.changes) == null ? void 0 : _c.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;

package/dist/index.cjs6.js

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

package/dist/index.cjs7.js

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

package/dist/index.cjs8.js

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

package/dist/index.cjs9.js

@@ -1,29 +1,5 @@
 "use strict";
-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;
+function createReactivityAdapter(definition) {
+  return definition;
 }
-module.exports = isEqual;
+module.exports = createReactivityAdapter;

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export type { default as PersistenceAdapter, Changeset, LoadResponse, } from './
 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 { 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';

package/dist/index.mjs

@@ -10,17 +10,19 @@ import { default as default10 } from "./index10.mjs";
 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";
 export {
-  default3 as AutoFetchCollection,
-  default2 as Collection,
-  default12 as EventEmitter,
-  default4 as combinePersistenceAdapters,
-  default13 as createIndex,
-  default5 as createIndexProvider,
-  default6 as createMemoryAdapter,
-  default7 as createPersistenceAdapter,
-  default8 as createReactivityAdapter,
-  default9 as isEqual,
-  default10 as modify,
-  default11 as randomId
+  default4 as AutoFetchCollection,
+  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
 };

package/dist/index10.mjs

@@ -1,13 +1,30 @@
-import { update } from "mingo";
-import deepClone from "./index15.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 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;
 }
 export {
-  modify as default
+  isEqual as default
 };

package/dist/index11.mjs

@@ -1,6 +1,13 @@
-function randomId() {
-  return Math.floor(Math.random() * 1e17).toString(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;
 }
 export {
-  randomId as default
+  modify as default
 };

package/dist/index12.mjs

@@ -1,139 +1,6 @@
-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);
-class EventEmitter {
-  constructor() {
-    __publicField(this, "_maxListeners", 100);
-    /**
-     * We store a set of the listeners for each event.
-     */
-    __publicField(this, "_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;
-  }
+function randomId() {
+  return Math.floor(Math.random() * 1e17).toString(16);
 }
 export {
-  EventEmitter as default
+  randomId as default
 };