@procedures/collections 0.47.1 → 0.47.2

package/dist/interfaces/queue.d.ts

@@ -1,304 +0,0 @@
-/**
- * Queue and Deque interfaces that mirror Java's Queue and Deque.
- *
- * Queues are collections designed for holding elements prior to processing.
- * Deques (double-ended queues) allow efficient insertion/removal at both ends.
- */
-import type { Collection, ReadonlyCollection } from "./collection.js";
-import type { Compare } from "../core/traits.js";
-/**
- * ReadonlyQueue<T> - Readonly FIFO (First-In-First-Out) queue.
- *
- * Provides read-only access to queue operations.
- */
-export interface ReadonlyQueue<T> extends ReadonlyCollection<T> {
-    /**
-     * Retrieves, but does not remove, the head of this queue.
-     *
-     * @returns The head element
-     * @throws Error if queue is empty
-     */
-    peek(): T;
-    /**
-     * Returns the head element without throwing if empty.
-     * Returns undefined if queue is empty.
-     */
-    peekOrUndefined(): T | undefined;
-}
-/**
- * Queue<T> - FIFO (First-In-First-Out) queue.
- *
- * Mirrors java.util.Queue.
- * Elements are processed in the order they were added.
- */
-export interface Queue<T> extends ReadonlyQueue<T>, Collection<T> {
-    /**
-     * Inserts an element into the queue.
-     * For bounded queues with overflow='throw', throws if queue is full.
-     *
-     * @param element The element to add
-     * @returns true if element was added
-     * @throws Error if queue is full (bounded with throw policy)
-     */
-    offer(element: T): boolean;
-    /**
-     * Retrieves and removes the head of this queue.
-     *
-     * @returns The head element
-     * @throws Error if queue is empty
-     */
-    poll(): T;
-    /**
-     * Retrieves and removes the head of this queue, or returns undefined if empty.
-     */
-    pollOrUndefined(): T | undefined;
-    /**
-     * Alias for offer(). Adds element to end of queue.
-     * Included for consistency with standard queue terminology.
-     */
-    enqueue(element: T): boolean;
-    /**
-     * Alias for poll(). Removes and returns element from front of queue.
-     * Included for consistency with standard queue terminology.
-     */
-    dequeue(): T;
-}
-/**
- * Deque<T> - Double-ended queue.
- *
- * Mirrors java.util.Deque.
- * Supports insertion and removal at both ends.
- * Can be used as a queue (FIFO) or stack (LIFO).
- */
-export interface Deque<T> extends Queue<T> {
-    /**
-     * Inserts element at the front of this deque.
-     *
-     * @param element The element to add
-     * @throws Error if deque is full (bounded with throw policy)
-     */
-    addFirst(element: T): void;
-    /**
-     * Inserts element at the front, returning false if full.
-     */
-    offerFirst(element: T): boolean;
-    /**
-     * Retrieves and removes the first element.
-     *
-     * @throws Error if deque is empty
-     */
-    removeFirst(): T;
-    /**
-     * Retrieves and removes the first element, or undefined if empty.
-     */
-    pollFirst(): T | undefined;
-    /**
-     * Retrieves but does not remove the first element.
-     *
-     * @throws Error if deque is empty
-     */
-    peekFirst(): T;
-    /**
-     * Retrieves but does not remove the first element, or undefined if empty.
-     */
-    peekFirstOrUndefined(): T | undefined;
-    /**
-     * Inserts element at the end of this deque.
-     *
-     * @param element The element to add
-     * @throws Error if deque is full (bounded with throw policy)
-     */
-    addLast(element: T): void;
-    /**
-     * Inserts element at the end, returning false if full.
-     */
-    offerLast(element: T): boolean;
-    /**
-     * Retrieves and removes the last element.
-     *
-     * @throws Error if deque is empty
-     */
-    removeLast(): T;
-    /**
-     * Retrieves and removes the last element, or undefined if empty.
-     */
-    pollLast(): T | undefined;
-    /**
-     * Retrieves but does not remove the last element.
-     *
-     * @throws Error if deque is empty
-     */
-    peekLast(): T;
-    /**
-     * Retrieves but does not remove the last element, or undefined if empty.
-     */
-    peekLastOrUndefined(): T | undefined;
-    /**
-     * Pushes element onto the stack represented by this deque.
-     * Equivalent to addLast().
-     *
-     * @param element The element to push
-     */
-    push(element: T): void;
-    /**
-     * Pops an element from the stack represented by this deque.
-     * Equivalent to removeLast().
-     *
-     * @returns The popped element
-     * @throws Error if deque is empty
-     */
-    pop(): T;
-}
-/**
- * BlockingQueue<T> - Queue that supports blocking operations.
- *
- * Mirrors java.util.concurrent.BlockingQueue.
- * Useful for producer-consumer patterns.
- */
-export interface BlockingQueue<T> extends Queue<T> {
-    /**
-     * Inserts element, waiting if necessary for space to become available.
-     *
-     * @param element The element to add
-     * @param timeoutMs Optional timeout in milliseconds
-     * @returns Promise that resolves to true when element is added
-     * @throws Error if timeout expires
-     */
-    put(element: T, timeoutMs?: number): Promise<void>;
-    /**
-     * Retrieves and removes the head, waiting if necessary until an element is available.
-     *
-     * @param timeoutMs Optional timeout in milliseconds
-     * @returns Promise that resolves to the head element
-     * @throws Error if timeout expires
-     */
-    take(timeoutMs?: number): Promise<T>;
-    /**
-     * Returns the remaining capacity.
-     * Returns Infinity for unbounded queues.
-     */
-    readonly remainingCapacity: number;
-    /**
-     * Removes all available elements and adds them to the given array.
-     * Returns the number of elements transferred.
-     */
-    drainTo(target: T[], maxElements?: number): number;
-}
-/**
- * PriorityQueue<T> - Queue that orders elements by priority.
- *
- * Mirrors java.util.PriorityQueue.
- * Elements are removed in priority order (not insertion order).
- * Requires a comparison function to determine priority.
- */
-export interface PriorityQueue<T> extends Queue<T> {
-    /**
-     * The comparison function used to determine priority.
-     * Elements with lower compare value have higher priority.
-     */
-    readonly compare: Compare<T>;
-    /**
-     * Returns the comparator used to order elements, or undefined if natural ordering.
-     */
-    readonly comparator: Compare<T> | undefined;
-}
-/**
- * AsyncQueue<T> - Async iterable queue.
- *
- * Designed for async/await patterns and streaming data.
- * Implements AsyncIterable for use with for-await-of loops.
- */
-export interface AsyncQueue<T> extends AsyncIterable<T> {
-    /** Number of elements currently in queue */
-    readonly size: number;
-    /** True if queue is empty */
-    readonly isEmpty: boolean;
-    /**
-     * Adds element to queue.
-     * For bounded queues, may wait for space to become available.
-     */
-    put(element: T): Promise<void>;
-    /**
-     * Removes and returns next element.
-     * Waits for an element if queue is empty.
-     */
-    take(): Promise<T>;
-    /**
-     * Attempts to add element without waiting.
-     * Returns false if queue is full.
-     */
-    tryPut(element: T): boolean;
-    /**
-     * Attempts to remove element without waiting.
-     * Returns undefined if queue is empty.
-     */
-    tryTake(): T | undefined;
-    /**
-     * Returns next element without removing it.
-     * Waits for an element if queue is empty.
-     */
-    peek(): Promise<T>;
-    /**
-     * Closes the queue, preventing further additions.
-     * Allows existing elements to be consumed.
-     */
-    close(): void;
-    /**
-     * Returns true if queue is closed.
-     */
-    readonly isClosed: boolean;
-}
-/**
- * TransferQueue<T> - Queue where producers can wait for consumers.
- *
- * Mirrors java.util.concurrent.TransferQueue.
- * Useful for direct handoff between producer and consumer threads.
- */
-export interface TransferQueue<T> extends BlockingQueue<T> {
-    /**
-     * Transfers element to consumer, waiting if necessary.
-     * Waits for a consumer to receive the element.
-     *
-     * @param element The element to transfer
-     * @returns Promise that resolves when element is received
-     */
-    transfer(element: T): Promise<void>;
-    /**
-     * Attempts to transfer element to waiting consumer.
-     * Returns false immediately if no consumer is waiting.
-     *
-     * @param element The element to transfer
-     * @param timeoutMs Optional timeout in milliseconds
-     */
-    tryTransfer(element: T, timeoutMs?: number): Promise<boolean>;
-    /**
-     * Returns true if there are consumers waiting to receive elements.
-     */
-    readonly hasWaitingConsumer: boolean;
-    /**
-     * Returns an estimate of the number of consumers waiting to receive elements.
-     */
-    readonly waitingConsumerCount: number;
-}
-/**
- * DelayQueue<T> - Queue where elements become available after a delay.
- *
- * Mirrors java.util.concurrent.DelayQueue.
- * Elements can only be removed once their delay has expired.
- */
-export interface DelayQueue<T> extends BlockingQueue<T> {
-    /**
-     * Adds element with specified delay.
-     *
-     * @param element The element to add
-     * @param delayMs Delay in milliseconds before element becomes available (defaults to 0)
-     */
-    offer(element: T, delayMs?: number): boolean;
-    /**
-     * Returns the delay (in ms) until next element becomes available.
-     * Returns 0 if element is ready now.
-     * Returns Infinity if queue is empty.
-     */
-    readonly nextDelay: number;
-}
-//# sourceMappingURL=queue.d.ts.map

package/dist/interfaces/queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../src/interfaces/queue.ts"],"names":[],"mappings":"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"}

package/dist/interfaces/queue.js

@@ -1,8 +0,0 @@
-/**
- * Queue and Deque interfaces that mirror Java's Queue and Deque.
- *
- * Queues are collections designed for holding elements prior to processing.
- * Deques (double-ended queues) allow efficient insertion/removal at both ends.
- */
-export {};
-//# sourceMappingURL=queue.js.map

package/dist/interfaces/queue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../src/interfaces/queue.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/interfaces/set.d.ts

@@ -1,137 +0,0 @@
-/**
- * Set interfaces that mirror Java's Set interface hierarchy.
- *
- * Sets are collections that contain no duplicate elements.
- * They provide efficient membership testing.
- */
-import type { Collection, ReadonlyCollection } from "./collection.js";
-import type { Compare } from "../core/traits.js";
-/**
- * ReadonlySet<T> - Readonly set with no duplicates.
- */
-export interface ReadonlySet<T> extends ReadonlyCollection<T> {
-    /**
-     * Returns true if this set contains the specified element.
-     */
-    contains(element: T): boolean;
-    /**
-     * Returns true if this set contains all elements in the specified collection.
-     */
-    containsAll(other: Iterable<T>): boolean;
-}
-/**
- * Set<T> - Mutable set with no duplicates.
- *
- * Mirrors java.util.Set.
- * Elements are unique based on the set's equality function.
- */
-export interface Set<T> extends ReadonlySet<T>, Collection<T> {
-    /**
-     * Adds the specified element to this set if it is not already present.
-     *
-     * @returns true if this set did not already contain the element
-     */
-    add(element: T): boolean;
-    /**
-     * Removes the specified element from this set if it is present.
-     *
-     * @returns true if this set contained the element
-     */
-    remove(element: T): boolean;
-    /**
-     * Adds all elements in the specified collection to this set.
-     * This is a union operation.
-     *
-     * @returns true if this set changed
-     */
-    addAll(other: Iterable<T>): boolean;
-    /**
-     * Removes from this set all of its elements that are contained in the specified collection.
-     * This is a difference operation.
-     *
-     * @returns true if this set changed
-     */
-    removeAll(other: Iterable<T>): boolean;
-    /**
-     * Retains only the elements in this set that are contained in the specified collection.
-     * This is an intersection operation.
-     *
-     * @returns true if this set changed
-     */
-    retainAll(other: Iterable<T>): boolean;
-}
-/**
- * SortedSet<T> - Set that maintains elements in sorted order.
- *
- * Mirrors java.util.SortedSet.
- */
-export interface SortedSet<T> extends Set<T> {
-    /**
-     * Returns the comparator used to order elements in this set.
-     */
-    readonly comparator: Compare<T>;
-    /**
-     * Returns the first (lowest) element in this set.
-     *
-     * @throws Error if set is empty
-     */
-    first(): T;
-    /**
-     * Returns the last (highest) element in this set.
-     *
-     * @throws Error if set is empty
-     */
-    last(): T;
-    /**
-     * Returns a view of the portion of this set whose elements are strictly less than toElement.
-     */
-    headSet(toElement: T): SortedSet<T>;
-    /**
-     * Returns a view of the portion of this set whose elements are greater than or equal to fromElement.
-     */
-    tailSet(fromElement: T): SortedSet<T>;
-    /**
-     * Returns a view of the portion of this set whose elements range from fromElement to toElement.
-     */
-    subSet(fromElement: T, toElement: T): SortedSet<T>;
-}
-/**
- * NavigableSet<T> - Extended sorted set with navigation methods.
- *
- * Mirrors java.util.NavigableSet.
- */
-export interface NavigableSet<T> extends SortedSet<T> {
-    /**
-     * Returns the greatest element less than or equal to the given element, or undefined if none.
-     */
-    floor(element: T): T | undefined;
-    /**
-     * Returns the least element greater than or equal to the given element, or undefined if none.
-     */
-    ceiling(element: T): T | undefined;
-    /**
-     * Returns the greatest element strictly less than the given element, or undefined if none.
-     */
-    lower(element: T): T | undefined;
-    /**
-     * Returns the least element strictly greater than the given element, or undefined if none.
-     */
-    higher(element: T): T | undefined;
-    /**
-     * Retrieves and removes the first (lowest) element, or returns undefined if empty.
-     */
-    pollFirst(): T | undefined;
-    /**
-     * Retrieves and removes the last (highest) element, or returns undefined if empty.
-     */
-    pollLast(): T | undefined;
-    /**
-     * Returns a reverse order view of this set.
-     */
-    descendingSet(): NavigableSet<T>;
-    /**
-     * Returns a reverse order iterator over the elements in this set.
-     */
-    descendingIterator(): Iterator<T>;
-}
-//# sourceMappingURL=set.d.ts.map

package/dist/interfaces/set.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/interfaces/set.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC3D;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC;IAE9B;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;CAC1C;AAED;;;;;GAKG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;IAC3D;;;;OAIG;IACH,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC;IAEzB;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC;IAE5B;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAEpC;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAEvC;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;CACxC;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAC;IAC1C;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAEhC;;;;OAIG;IACH,KAAK,IAAI,CAAC,CAAC;IAEX;;;;OAIG;IACH,IAAI,IAAI,CAAC,CAAC;IAEV;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IAEpC;;OAEG;IACH,OAAO,CAAC,WAAW,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IAEtC;;OAEG;IACH,MAAM,CAAC,WAAW,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;CACpD;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IACnD;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAEjC;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAEnC;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAEjC;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAElC;;OAEG;IACH,SAAS,IAAI,CAAC,GAAG,SAAS,CAAC;IAE3B;;OAEG;IACH,QAAQ,IAAI,CAAC,GAAG,SAAS,CAAC;IAE1B;;OAEG;IACH,aAAa,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;IAEjC;;OAEG;IACH,kBAAkB,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC;CACnC"}

package/dist/interfaces/set.js

@@ -1,8 +0,0 @@
-/**
- * Set interfaces that mirror Java's Set interface hierarchy.
- *
- * Sets are collections that contain no duplicate elements.
- * They provide efficient membership testing.
- */
-export {};
-//# sourceMappingURL=set.js.map

package/dist/interfaces/set.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"set.js","sourceRoot":"","sources":["../../src/interfaces/set.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/order/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * The order of a list as data (Graph's split, wave 2, W1). Each item keeps a string key, and the list
- * sorts by it. An item that moves between two others gets a key between theirs, so a move writes one
- * item and no other.
- */
-export { KEY_DIGITS, keyBetween, keysBetween, keysForDrop, compareKeys, isValidKey, dropIndex, type KeyCheckOptions, type KeyedItem, type Point } from "./rank.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/order/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/order/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAE,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC"}

package/dist/order/index.js

@@ -1,7 +0,0 @@
-/**
- * The order of a list as data (Graph's split, wave 2, W1). Each item keeps a string key, and the list
- * sorts by it. An item that moves between two others gets a key between theirs, so a move writes one
- * item and no other.
- */
-export { KEY_DIGITS, keyBetween, keysBetween, keysForDrop, compareKeys, isValidKey, dropIndex } from "./rank.js";
-//# sourceMappingURL=index.js.map

package/dist/order/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/order/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAoD,MAAM,WAAW,CAAC"}

package/dist/order/rank.d.ts

@@ -1,100 +0,0 @@
-/**
- * The keys of an ordered list (Graph's split, wave 2, W1): fractional indexing with base-62 keys. A
- * key is a string. Each item of the list keeps one, and the list sorts by it. An item that moves
- * between two others gets a key between theirs, so a move writes one item and no other.
- *
- * - A key has an integer part and a fraction part. The first character of the integer part gives its
- *   length. An insertion at an end changes the integer part, so the keys stay short. An insertion
- *   between two keys uses the fraction part, which can grow without a limit: the keys never run out,
- *   and the list needs no rebalance.
- * - Compare two keys by the code units of the strings (`a < b`), never with `localeCompare`.
- * - Two writers that move items into the same gap at the same time can get the same key. Sort by the
- *   key, then by the id of the item, so each reader sees one order.
- *
- * The algorithm is the one of the `fractional-indexing` package of Rocicorp (CC0), after the article
- * "Implementing Fractional Indexing" of David Greenspan.
- */
-/** The digits of a key, in ascending order of their code units. */
-export declare const KEY_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-/**
- * This function gives a key strictly between two keys. Without `prev`, the key comes before `next`.
- * Without `next`, it comes after `prev`. Without both, it gives the first key of a list ("a0").
- *
- * @throws RangeError when a key is not valid, or when `prev` is not before `next`
- *
- * @example
- * ```ts
- * keyBetween(undefined, undefined); // "a0"
- * keyBetween("a0", undefined); // "a1", after a0
- * keyBetween("a0", "a1"); // "a0V"
- * ```
- */
-export declare function keyBetween(prev: string | null | undefined, next: string | null | undefined): string;
-/**
- * This function gives `count` keys in ascending order, strictly between two keys, for example to put
- * several items at one place, or to give keys to the items of a list for the first time.
- *
- * @throws RangeError as `keyBetween`, or when `count` is not an integer of 0 or more
- */
-export declare function keysBetween(prev: string | null | undefined, next: string | null | undefined, count: number): string[];
-/** The options of `isValidKey`. */
-export interface KeyCheckOptions {
-    /** The longest key that the check accepts. The default is 1024 characters. */
-    readonly maxLength?: number;
-}
-/**
- * This function tells if a value is a valid key, for example a key that a client writes. A key that
- * is longer than `maxLength` is not valid.
- */
-export declare function isValidKey(key: unknown, options?: KeyCheckOptions): key is string;
-/** An item of an ordered list: its id and its key. */
-export interface KeyedItem {
-    readonly id: string;
-    readonly key: string;
-}
-/**
- * This function gives the writes of a move: the new key of the item that moves, and new keys for the
- * neighbors that need them. Give the other items of the list in order (by key, then by id), without
- * the item that moves, and the index of the drop from 0 to their number (`dropIndex`).
- *
- * Two writers can give two items one key. A drop between two such items has no key between them, so
- * the helper first gives new keys to the items after the drop that have the key of the item before
- * it. Each write is `{ id, key }`. The writes of the neighbors come first, and the write of the item
- * that moves comes last.
- *
- * @throws RangeError when the index is outside the list, when the list holds the item that moves, or
- * when a key is not valid
- *
- * @example
- * ```ts
- * const index = dropIndex(pointer, others.map(centerOf));
- * for (const { id, key } of keysForDrop(others, index, dragged.id)) await save(id, { rank: key });
- * ```
- */
-export declare function keysForDrop(items: readonly KeyedItem[], index: number, movingId: string): Array<{
-    id: string;
-    key: string;
-}>;
-/** The order of two keys: the code units of the strings, as the keys need (never `localeCompare`). */
-export declare function compareKeys(a: string, b: string): number;
-/** A point, for example the center of an item on the screen. */
-export interface Point {
-    readonly x: number;
-    readonly y: number;
-}
-/**
- * This function gives the index at which a point goes among the items of a list on the screen, in
- * reading order: the rows from top to bottom, and each row from left to right. It is the index of the
- * first item whose center comes after the point, from 0 to the number of items. A center within
- * `rowTolerance` of the point on the vertical axis is in the row of the point.
- *
- * Give the centers in reading order, the same order as the keys, and without the item that moves.
- *
- * @example
- * ```ts
- * const index = dropIndex(pointer, others.map(centerOf));
- * const key = keyBetween(keys[index - 1], keys[index]);
- * ```
- */
-export declare function dropIndex(point: Point, centers: readonly Point[], rowTolerance?: number): number;
-//# sourceMappingURL=rank.d.ts.map

package/dist/order/rank.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rank.d.ts","sourceRoot":"","sources":["../../src/order/rank.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,mEAAmE;AACnE,eAAO,MAAM,UAAU,mEAAmE,CAAC;AAuF3F;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CA6BnG;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAmBrH;AAED,mCAAmC;AACnC,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,eAAoB,GAAG,GAAG,IAAI,MAAM,CAQrF;AAED,sDAAsD;AACtD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAe5H;AAED,sGAAsG;AACtG,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,gEAAgE;AAChE,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,KAAK,EAAE,EAAE,YAAY,SAAK,GAAG,MAAM,CAO5F"}