chore: bump svelte deps

Author: wobsoriano

packages/db/src/SortedMap.d.ts

@@ -0,0 +1,101 @@
+/**
+ * A Map implementation that keeps its entries sorted based on a comparator function
+ * @template TKey - The type of keys in the map
+ * @template TValue - The type of values in the map
+ */
+export declare class SortedMap<TKey, TValue> {
+    private map;
+    private sortedKeys;
+    private comparator;
+    /**
+     * Creates a new SortedMap instance
+     *
+     * @param comparator - Optional function to compare values for sorting
+     */
+    constructor(comparator?: (a: TValue, b: TValue) => number);
+    /**
+     * Default comparator function used when none is provided
+     *
+     * @param a - First value to compare
+     * @param b - Second value to compare
+     * @returns -1 if a < b, 1 if a > b, 0 if equal
+     */
+    private defaultComparator;
+    /**
+     * Finds the index where a key-value pair should be inserted to maintain sort order.
+     * Uses binary search to find the correct position based on the value.
+     * Hence, it is in O(log n) time.
+     *
+     * @param key - The key to find position for
+     * @param value - The value to compare against
+     * @returns The index where the key should be inserted
+     */
+    private indexOf;
+    /**
+     * Sets a key-value pair in the map and maintains sort order
+     *
+     * @param key - The key to set
+     * @param value - The value to associate with the key
+     * @returns This SortedMap instance for chaining
+     */
+    set(key: TKey, value: TValue): this;
+    /**
+     * Gets a value by its key
+     *
+     * @param key - The key to look up
+     * @returns The value associated with the key, or undefined if not found
+     */
+    get(key: TKey): TValue | undefined;
+    /**
+     * Removes a key-value pair from the map
+     *
+     * @param key - The key to remove
+     * @returns True if the key was found and removed, false otherwise
+     */
+    delete(key: TKey): boolean;
+    /**
+     * Checks if a key exists in the map
+     *
+     * @param key - The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    has(key: TKey): boolean;
+    /**
+     * Removes all key-value pairs from the map
+     */
+    clear(): void;
+    /**
+     * Gets the number of key-value pairs in the map
+     */
+    get size(): number;
+    /**
+     * Default iterator that returns entries in sorted order
+     *
+     * @returns An iterator for the map's entries
+     */
+    [Symbol.iterator](): IterableIterator<[TKey, TValue]>;
+    /**
+     * Returns an iterator for the map's entries in sorted order
+     *
+     * @returns An iterator for the map's entries
+     */
+    entries(): IterableIterator<[TKey, TValue]>;
+    /**
+     * Returns an iterator for the map's keys in sorted order
+     *
+     * @returns An iterator for the map's keys
+     */
+    keys(): IterableIterator<TKey>;
+    /**
+     * Returns an iterator for the map's values in sorted order
+     *
+     * @returns An iterator for the map's values
+     */
+    values(): IterableIterator<TValue>;
+    /**
+     * Executes a callback function for each key-value pair in the map in sorted order
+     *
+     * @param callbackfn - Function to execute for each entry
+     */
+    forEach(callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void): void;
+}

packages/db/src/change-events.d.ts

@@ -0,0 +1,49 @@
+import type { ChangeMessage, CurrentStateAsChangesOptions, SubscribeChangesOptions } from "./types";
+import type { Collection } from "./collection";
+import type { SingleRowRefProxy } from "./query/builder/ref-proxy";
+import type { BasicExpression } from "./query/ir.js";
+/**
+ * Interface for a collection-like object that provides the necessary methods
+ * for the change events system to work
+ */
+export interface CollectionLike<T extends object = Record<string, unknown>, TKey extends string | number = string | number> extends Pick<Collection<T, TKey>, `get` | `has` | `entries` | `indexes`> {
+}
+/**
+ * Returns the current state of the collection as an array of changes
+ * @param collection - The collection to get changes from
+ * @param options - Options including optional where filter
+ * @returns An array of changes
+ * @example
+ * // Get all items as changes
+ * const allChanges = currentStateAsChanges(collection)
+ *
+ * // Get only items matching a condition
+ * const activeChanges = currentStateAsChanges(collection, {
+ *   where: (row) => row.status === 'active'
+ * })
+ *
+ * // Get only items using a pre-compiled expression
+ * const activeChanges = currentStateAsChanges(collection, {
+ *   whereExpression: eq(row.status, 'active')
+ * })
+ */
+export declare function currentStateAsChanges<T extends object, TKey extends string | number>(collection: CollectionLike<T, TKey>, options?: CurrentStateAsChangesOptions<T>): Array<ChangeMessage<T>>;
+/**
+ * Creates a filter function from a where callback
+ * @param whereCallback - The callback function that defines the filter condition
+ * @returns A function that takes an item and returns true if it matches the filter
+ */
+export declare function createFilterFunction<T extends object>(whereCallback: (row: SingleRowRefProxy<T>) => any): (item: T) => boolean;
+/**
+ * Creates a filter function from a pre-compiled expression
+ * @param expression - The pre-compiled expression to evaluate
+ * @returns A function that takes an item and returns true if it matches the filter
+ */
+export declare function createFilterFunctionFromExpression<T extends object>(expression: BasicExpression<boolean>): (item: T) => boolean;
+/**
+ * Creates a filtered callback that only calls the original callback with changes that match the where clause
+ * @param originalCallback - The original callback to filter
+ * @param options - The subscription options containing the where clause
+ * @returns A filtered callback function
+ */
+export declare function createFilteredCallback<T extends object>(originalCallback: (changes: Array<ChangeMessage<T>>) => void, options: SubscribeChangesOptions<T>): (changes: Array<ChangeMessage<T>>) => void;