@signaldb/core 1.0.0

package/dist/index20.mjs

@@ -0,0 +1,80 @@
+import Collection from "./index2.mjs";
+import combinePersistenceAdapters from "./index4.mjs";
+import createPersistenceAdapter from "./index7.mjs";
+import createSignal from "./index17.mjs";
+function createReplicationAdapter(options) {
+  return createPersistenceAdapter({
+    async register(onChange) {
+      if (!options.registerRemoteChange)
+        return;
+      await options.registerRemoteChange(onChange);
+    },
+    load: () => options.pull(),
+    save: (items, changes) => {
+      if (!options.push)
+        throw new Error("Pushing is not configured for this collection. Try to pass a `push` function to the collection options.");
+      return options.push(changes, items);
+    }
+  });
+}
+class ReplicatedCollection extends Collection {
+  /**
+   * Creates a new instance of the `ReplicatedCollection` class.
+   * Sets up the replication adapter, combining it with an optional persistence adapter, and
+   * initializes signals for tracking remote pull and push operations.
+   * @param options - The configuration options for the replicated collection.
+   * @param options.pull - A function to fetch data from the remote source.
+   * @param options.push - An optional function to send changes and items to the remote source.
+   * @param options.registerRemoteChange - An optional function to register a listener for remote changes.
+   * @param options.persistence - An optional persistence adapter to combine with replication.
+   * @param options.reactivity - A reactivity adapter for observing changes in the collection.
+   * @param options.transform - A transformation function to apply to items when retrieving them.
+   * @param options.indices - An array of index providers for optimized querying.
+   * @param options.enableDebugMode - A boolean to enable or disable debug mode.
+   */
+  constructor(options) {
+    var _a, _b;
+    const replicationAdapter = createReplicationAdapter({
+      registerRemoteChange: options.registerRemoteChange,
+      pull: async () => {
+        this.isPullingRemoteSignal.set(true);
+        try {
+          return await options.pull();
+        } finally {
+          this.isPullingRemoteSignal.set(false);
+        }
+      },
+      push: options.push ? async (changes, items) => {
+        if (!options.push)
+          throw new Error("Pushing is not configured for this collection. Try to pass a `push` function to the collection options.");
+        this.isPushingRemoteSignal.set(true);
+        try {
+          await options.push(changes, items);
+        } finally {
+          this.isPushingRemoteSignal.set(false);
+        }
+      } : void 0
+    });
+    const persistenceAdapter = (options === null || options === void 0 ? void 0 : options.persistence) ? combinePersistenceAdapters(replicationAdapter, options.persistence) : replicationAdapter;
+    super(Object.assign(Object.assign({}, options), { persistence: persistenceAdapter }));
+    this.isPullingRemoteSignal = createSignal((_a = options.reactivity) === null || _a === void 0 ? void 0 : _a.create(), false);
+    this.isPushingRemoteSignal = createSignal((_b = options.reactivity) === null || _b === void 0 ? void 0 : _b.create(), false);
+  }
+  /**
+   * Checks whether the collection is currently performing any loading operation,
+   * including pulling or pushing data from/to the remote source, or standard
+   * persistence adapter operations.
+   * ⚡️ this function is reactive!
+   * @returns A boolean indicating if the collection is currently loading or synchronizing.
+   */
+  isLoading() {
+    const isPullingRemote = this.isPullingRemoteSignal.get();
+    const isPushingRemote = this.isPushingRemoteSignal.get();
+    const isLoading = super.isLoading();
+    return isPullingRemote || isPushingRemote || isLoading;
+  }
+}
+export {
+  createReplicationAdapter,
+  ReplicatedCollection as default
+};

package/dist/index21.mjs

@@ -0,0 +1,11 @@
+import { sort } from "fast-sort";
+import get from "./index26.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) };
+  }));
+}
+export {
+  sortItems as default
+};

package/dist/index22.mjs

@@ -0,0 +1,28 @@
+import get from "./index26.mjs";
+import set from "./index29.mjs";
+function project(item, fields) {
+  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
+  if (allFieldsDeactivated) {
+    const result2 = Object.assign({}, 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;
+}
+export {
+  project as default
+};

package/dist/index23.mjs

@@ -0,0 +1,138 @@
+import isEqual from "./index9.mjs";
+import uniqueBy from "./index30.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) {
+    this.previousItems = [];
+    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"])) {
+            if (!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 || _a === void 0 ? void 0 : _a.id) !== (oldBeforeItem === null || oldBeforeItem === void 0 ? 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) => Object.assign(Object.assign({}, callback), { options: Object.assign(Object.assign({}, 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 {
+  Observer as default
+};

package/dist/index24.mjs

@@ -0,0 +1,18 @@
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+export {
+  __rest
+};

package/dist/index25.mjs

@@ -0,0 +1,8 @@
+function intersection(...arrays) {
+  if (arrays.length === 0)
+    return [];
+  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+}
+export {
+  intersection as default
+};

package/dist/index26.mjs

@@ -0,0 +1,20 @@
+function get(value, path) {
+  const segments = path.split(/[.[\]]/g);
+  if (segments[0] === "")
+    segments.shift();
+  if (segments[segments.length - 1] === "")
+    segments.pop();
+  let current = value;
+  for (let i = 0; i < segments.length; i += 1) {
+    const key = segments[i];
+    if (current == null || key.trim() === "")
+      return void 0;
+    current = current[key];
+  }
+  if (current === void 0)
+    return void 0;
+  return current;
+}
+export {
+  get as default
+};

package/dist/index27.mjs

@@ -0,0 +1,25 @@
+import isFieldExpression from "./index28.mjs";
+import serializeValue from "./index16.mjs";
+function getMatchingKeys(field, selector) {
+  if (selector[field] instanceof RegExp)
+    return null;
+  if (selector[field] != null) {
+    if (isFieldExpression(selector[field])) {
+      const is$in = isFieldExpression(selector[field]) && Array.isArray(selector[field].$in) && selector[field].$in.length;
+      if (is$in) {
+        const optimizedSelector = Object.assign(Object.assign({}, selector), { [field]: Object.assign({}, selector[field]) });
+        delete optimizedSelector[field].$in;
+        if (Object.keys(optimizedSelector[field]).length === 0) {
+          delete optimizedSelector[field];
+        }
+        return selector[field].$in.map(serializeValue);
+      }
+      return null;
+    }
+    return [serializeValue(selector[field])];
+  }
+  return null;
+}
+export {
+  getMatchingKeys as default
+};

package/dist/index28.mjs

@@ -0,0 +1,43 @@
+const expressionKeys = [
+  "$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.includes(key));
+  if (hasInvalidKeys)
+    return false;
+  const hasValidKeys = keys.every((key) => expressionKeys.includes(key));
+  return hasValidKeys;
+}
+export {
+  isFieldExpression as default
+};

package/dist/index29.mjs

@@ -0,0 +1,30 @@
+function set(obj, path, value, deleteIfUndefined = false) {
+  if (obj == null)
+    return obj;
+  const segments = path.split(/[.[\]]/g);
+  if (segments[0] === "")
+    segments.shift();
+  if (segments[segments.length - 1] === "")
+    segments.pop();
+  const apply = (node) => {
+    if (segments.length > 1) {
+      const key = segments.shift();
+      const nextIsNum = !Number.isNaN(parseInt(segments[0], 10));
+      if (node[key] === void 0) {
+        node[key] = nextIsNum ? [] : {};
+      }
+      apply(node[key]);
+    } else {
+      if (deleteIfUndefined && value === void 0) {
+        delete node[segments[0]];
+        return;
+      }
+      node[segments[0]] = value;
+    }
+  };
+  apply(obj);
+  return obj;
+}
+export {
+  set as default
+};

package/dist/index3.mjs

@@ -0,0 +1,166 @@
+import ReplicatedCollection from "./index20.mjs";
+import createSignal from "./index17.mjs";
+class AutoFetchCollection extends ReplicatedCollection {
+  /**
+   * @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) {
+    var _a, _b, _c, _d;
+    let triggerRemoteChange;
+    super(Object.assign(Object.assign({}, 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;
+      return Promise.resolve();
+    } }));
+    this.activeObservers = /* @__PURE__ */ new Map();
+    this.observerTimeouts = /* @__PURE__ */ new Map();
+    this.idQueryCache = /* @__PURE__ */ new Map();
+    this.itemsCache = /* @__PURE__ */ new Map();
+    this.triggerReload = null;
+    this.reactivityAdapter = null;
+    this.loadingSignals = /* @__PURE__ */ new Map();
+    this.mergeItems = (_a = options.mergeItems) !== null && _a !== void 0 ? _a : (itemA, itemB) => Object.assign(Object.assign({}, itemA), itemB);
+    this.purgeDelay = (_b = options.purgeDelay) !== null && _b !== void 0 ? _b : 1e4;
+    this.isFetchingSignal = createSignal((_c = options.reactivity) === null || _c === void 0 ? void 0 : _c.create(), false);
+    if (!triggerRemoteChange)
+      throw new Error("No triggerRemoteChange method found. Looks like your persistence adapter was not registered");
+    this.triggerReload = triggerRemoteChange;
+    this.reactivityAdapter = (_d = options.reactivity) !== null && _d !== void 0 ? _d : null;
+    this.fetchQueryItems = options.fetchQueryItems;
+    this.on("observer.created", (selector) => this.handleObserverCreation(selector !== null && selector !== void 0 ? selector : {}));
+    this.on("observer.disposed", (selector) => setTimeout(() => this.handleObserverDisposal(selector !== null && selector !== void 0 ? 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);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  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) => {
+        var _a;
+        const queries = (_a = this.idQueryCache.get(item.id)) !== null && _a !== void 0 ? _a : [];
+        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, _b;
+    const activeObservers = (_b = (_a = this.activeObservers.get(this.getKeyForSelector(selector))) === null || _a === void 0 ? void 0 : _a.count) !== null && _b !== void 0 ? _b : 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, _b;
+    const currentObservers = (_b = (_a = this.activeObservers.get(this.getKeyForSelector(selector))) === null || _a === void 0 ? void 0 : _a.count) !== null && _b !== void 0 ? _b : 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.create(), 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;
+  }
+}
+export {
+  AutoFetchCollection as default
+};

package/dist/index30.mjs

@@ -0,0 +1,10 @@
+function uniqueBy(arr, fn) {
+  const set = /* @__PURE__ */ new Set();
+  return arr.filter((el) => {
+    const value = typeof fn === "function" ? fn(el) : el[fn];
+    return !set.has(value) && set.add(value);
+  });
+}
+export {
+  uniqueBy as default
+};

package/dist/index4.mjs

@@ -0,0 +1,70 @@
+import createPersistenceAdapter from "./index7.mjs";
+function createTemporaryFallbackExecutor(firstResolvingPromiseFn, secondResolvingPromiseFn, options) {
+  var _a;
+  const cacheTimeout = (_a = options === null || options === void 0 ? void 0 : options.cacheTimeout) !== null && _a !== void 0 ? _a : 0;
+  let isResolved = false;
+  let resolvedValue = null;
+  let timeout = null;
+  let secondaryPromise = null;
+  return (...args) => {
+    if (secondaryPromise == null) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      secondaryPromise = secondResolvingPromiseFn(...args).then((result) => {
+        if (cacheTimeout > 0) {
+          timeout = setTimeout(() => {
+            isResolved = false;
+            resolvedValue = null;
+            secondaryPromise = null;
+          }, cacheTimeout);
+        }
+        isResolved = true;
+        resolvedValue = result;
+        if (options === null || options === void 0 ? void 0 : options.onResolve)
+          options.onResolve(resolvedValue);
+        return result;
+      });
+    } else if (isResolved) {
+      return secondaryPromise;
+    }
+    return firstResolvingPromiseFn(...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 || _a === void 0 ? void 0 : _a.added) || [],
+        modified: ((_b = result.changes) === null || _b === void 0 ? void 0 : _b.modified) || [],
+        removed: ((_c = result.changes) === null || _c === void 0 ? 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)
+      ]);
+    }
+  });
+}
+export {
+  createTemporaryFallbackExecutor,
+  combinePersistenceAdapters as default
+};

package/dist/index5.mjs

@@ -0,0 +1,6 @@
+function createIndexProvider(definition) {
+  return definition;
+}
+export {
+  createIndexProvider as default
+};

package/dist/index6.mjs

@@ -0,0 +1,6 @@
+function createMemoryAdapter(definition) {
+  return definition;
+}
+export {
+  createMemoryAdapter as default
+};

package/dist/index7.mjs

@@ -0,0 +1,6 @@
+function createPersistenceAdapter(definition) {
+  return definition;
+}
+export {
+  createPersistenceAdapter as default
+};