@signaldb/core 1.7.1 → 2.0.0-beta.1

package/dist/AutoFetchCollection.d.ts

@@ -1,60 +0,0 @@
-import type { BaseItem } from './Collection';
-import type { ReplicatedCollectionOptions } from './ReplicatedCollection';
-import ReplicatedCollection from './ReplicatedCollection';
-import type Selector from './types/Selector';
-interface AutoFetchOptions<T extends {
-    id: I;
-} & Record<string, any>, I> {
-    fetchQueryItems: (selector: Selector<T>) => ReturnType<ReplicatedCollectionOptions<T, I>['pull']>;
-    purgeDelay?: number;
-    registerRemoteChange?: (onChange: () => Promise<void>) => Promise<void>;
-    mergeItems?: (itemA: T, itemB: T) => T;
-}
-export type AutoFetchCollectionOptions<T extends BaseItem<I>, I, U = T> = Omit<ReplicatedCollectionOptions<T, I, U>, 'pull' | 'registerRemoteChange'> & AutoFetchOptions<T, I>;
-/**
- * A special collection that automatically fetches items when they are needed.
- */
-export default class AutoFetchCollection<T extends BaseItem<I> = BaseItem, I = any, U = T> extends ReplicatedCollection<T, I, U> {
-    private activeObservers;
-    private observerTimeouts;
-    private purgeDelay;
-    private idQueryCache;
-    private itemsCache;
-    private fetchQueryItems;
-    private triggerReload;
-    private reactivityAdapter;
-    private loadingSignals;
-    private isFetchingSignal;
-    private 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: AutoFetchCollectionOptions<T, I, U>);
-    /**
-     * Registers a query manually that items should be fetched for it
-     * @param selector {Object} Selector of the query
-     */
-    registerQuery(selector: Selector<T>): void;
-    /**
-     * Unregisters a query manually that items are not fetched anymore for it
-     * @param selector {Object} Selector of the query
-     */
-    unregisterQuery(selector: Selector<T>): void;
-    private getKeyForSelector;
-    private forceRefetch;
-    private fetchSelector;
-    private handleObserverCreation;
-    private handleObserverDisposal;
-    private ensureSignal;
-    private setLoading;
-    /**
-     * 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?: Selector<T>): boolean;
-}
-export {};

package/dist/Collection/createIndex.d.ts

@@ -1,15 +0,0 @@
-import type IndexProvider from '../types/IndexProvider';
-import type { BaseItem } from './types';
-/**
- * creates an index for a specific field but uses an external map to store the index
- * @param field name of the field
- * @param index the external map to use for the index
- * @returns an index provider to pass to the `indices` option of the collection constructor
- */
-export declare function createExternalIndex<T extends BaseItem<I> = BaseItem, I = any>(field: string, index: Map<string | undefined | null, Set<number>>): IndexProvider<T, I>;
-/**
- * creates an index for a specific field
- * @param field name of the field
- * @returns an index provider to pass to the `indices` option of the collection constructor
- */
-export default function createIndex<T extends BaseItem<I> = BaseItem, I = any>(field: string): IndexProvider<T, I>;

package/dist/ReplicatedCollection.d.ts

@@ -1,60 +0,0 @@
-import Collection from './Collection';
-import type { BaseItem, CollectionOptions } from './Collection';
-import type { Changeset, LoadResponse } from './types/PersistenceAdapter';
-interface ReplicationOptions<T extends {
-    id: I;
-} & Record<string, any>, I> {
-    pull: () => Promise<LoadResponse<T>>;
-    push?(changes: Changeset<T>, items: T[]): Promise<void>;
-    registerRemoteChange?: (onChange: (data?: LoadResponse<T>) => void | Promise<void>) => Promise<void>;
-}
-/**
- * Creates a persistence adapter for replicating a collection, enabling pull and push
- * operations for synchronizing with a remote source. Supports optional remote change registration.
- * @template T - The type of the items being replicated.
- * @template I - The type of the unique identifier for the items.
- * @param options - The options for configuring the replication adapter.
- * @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.
- * @returns A persistence adapter configured for replication.
- */
-export declare function createReplicationAdapter<T extends {
-    id: I;
-} & Record<string, any>, I>(options: ReplicationOptions<T, I>): import("./types/PersistenceAdapter").default<T, unknown>;
-export type ReplicatedCollectionOptions<T extends BaseItem<I>, I, U = T> = CollectionOptions<T, I, U> & ReplicationOptions<T, I>;
-/**
- * Extends the `Collection` class to support replication with remote sources.
- * Handles pull and push operations, remote change registration, and enhanced loading states.
- * @template T - The type of the items in the collection.
- * @template I - The type of the unique identifier for the items.
- * @template U - The transformed item type after applying transformations (default is T).
- */
-export default class ReplicatedCollection<T extends BaseItem<I> = BaseItem, I = any, U = T> extends Collection<T, I, U> {
-    private isPullingRemoteSignal;
-    private isPushingRemoteSignal;
-    /**
-     * 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: ReplicatedCollectionOptions<T, I, U>);
-    /**
-     * 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(): boolean;
-}
-export {};

package/dist/createMemoryAdapter.d.ts

@@ -1,7 +0,0 @@
-import type MemoryAdapter from './types/MemoryAdapter';
-/**
- * Creates an MemoryAdapter based on the given definition.
- * @param definition - The definition of the MemoryAdapter.
- * @returns The created MemoryAdapter.
- */
-export default function createMemoryAdapter(definition: MemoryAdapter): MemoryAdapter<Record<string, any>>;

package/dist/persistence/combinePersistenceAdapters.d.ts

@@ -1,32 +0,0 @@
-import type PersistenceAdapter from '../types/PersistenceAdapter';
-/**
- * Creates a function that executes two asynchronous functions sequentially.
- * The first function is tried first, and if it resolves, its value is used.
- * If the first function fails or a fallback is required, the second function is executed.
- * An optional cache mechanism can store the result temporarily to improve performance.
- * @template Arguments - The argument types for the promise functions.
- * @template ReturnValue - The return value type of the promise functions.
- * @param firstResolvingPromiseFunction - The primary promise-based function to execute.
- * @param secondResolvingPromiseFunction - The secondary fallback promise-based function to execute.
- * @param [options] - Optional configuration.
- * @param [options.onResolve] - Callback executed when a promise resolves.
- * @param [options.cacheTimeout] - Time (in ms) to cache the resolved result.
- * @returns A function that executes the two promises as described.
- */
-export declare function createTemporaryFallbackExecutor<Arguments extends Array<any>, ReturnValue>(firstResolvingPromiseFunction: (...args: Arguments) => Promise<ReturnValue>, secondResolvingPromiseFunction: (...args: Arguments) => Promise<ReturnValue>, options?: {
-    onResolve?: (returnValue: ReturnValue) => void;
-    cacheTimeout?: number;
-}): (...args: Arguments) => Promise<ReturnValue>;
-/**
- * Combines two persistence adapters (fast and slow) into a single interface.
- * The fast adapter is used for quick read and write operations, while the slow adapter
- * ensures data persistence and durability. The adapters sync automatically on read and save operations.
- * @template T - The type of the persisted data items.
- * @template I - The type of the identifier for persisted data items.
- * @param slowAdapter - The slow persistence adapter for long-term storage.
- * @param fastAdapter - The fast persistence adapter for quick access.
- * @returns A combined persistence adapter that manages synchronization between the two adapters.
- */
-export default function combinePersistenceAdapters<T extends {
-    id: I;
-} & Record<string, any>, I>(slowAdapter: PersistenceAdapter<T, I>, fastAdapter: PersistenceAdapter<T, I>): PersistenceAdapter<T, I>;

package/dist/persistence/createPersistenceAdapter.d.ts

@@ -1,9 +0,0 @@
-import type PersistenceAdapter from '../types/PersistenceAdapter';
-/**
- * Creates an PersistenceAdapter based on the given definition.
- * @param definition - The definition of the PersistenceAdapter.
- * @returns The created PersistenceAdapter.
- */
-export default function createPersistenceAdapter<T extends {
-    id: I;
-} & Record<string, any>, I>(definition: PersistenceAdapter<T, I>): PersistenceAdapter<T, I>;

package/dist/types/MemoryAdapter.d.ts

@@ -1,15 +0,0 @@
-/**
- * Abstract class representing a memory adapter that implements methods
- * from the JavaScript `Array` class for data manipulation.
- * Designed to be extended and customized for specific use cases.
- * @template T - The type of the items stored in the memory adapter (default is a record of key-value pairs).
- */
-export default abstract class MemoryAdapter<T = Record<string, any>> {
-    abstract push(item: T): void;
-    abstract pop(): T | undefined;
-    abstract splice(start: number, deleteCount?: number, ...items: T[]): T[];
-    abstract map<U>(callbackfn: (value: T, index: number, array: T[]) => U): U[];
-    abstract find(predicate: (value: T, index: number, object: T[]) => boolean): T | undefined;
-    abstract filter(predicate: (value: T, index: number, array: T[]) => unknown): T[];
-    abstract findIndex(predicate: (value: T, index: number, object: T[]) => boolean): number;
-}

package/dist/types/PersistenceAdapter.d.ts

@@ -1,20 +0,0 @@
-export interface Changeset<T> {
-    added: T[];
-    modified: T[];
-    removed: T[];
-}
-export type LoadResponse<T> = {
-    items: T[];
-    changes?: never;
-} | {
-    changes: Changeset<T>;
-    items?: never;
-};
-export default interface PersistenceAdapter<T extends {
-    id: I;
-} & Record<string, any>, I> {
-    load(): Promise<LoadResponse<T>>;
-    save(items: T[], changes: Changeset<T>): Promise<void>;
-    register(onChange: (data?: LoadResponse<T>) => void | Promise<void>): Promise<void>;
-    unregister?(): Promise<void>;
-}