reactronic/build/dist/source/util/LinkedList.d.ts

Reactronic - Transactional Reactive State Management

export type Extractor<T, Result> = (item: T) => Result;
export type KeyExtractor<T> = Extractor<T, string | undefined>;
export declare class LinkedList<T extends LinkedItem<T>> {
    readonly keyExtractor: KeyExtractor<T>;
    private isStrictOrder$;
    private map;
    items$: LinkedSubList<T>;
    private renovation$;
    constructor(keyExtractor: KeyExtractor<T>, isStrictOrder?: boolean);
    get isStrictOrder(): boolean;
    set isStrictOrder(value: boolean);
    get renovation(): LinkedListRenovation<T>;
    get isRenovationInProgress(): boolean;
    get count(): number;
    get firstItem(): T | undefined;
    get lastItem(): T | undefined;
    items(after?: T): Generator<T>;
    tryLookup(key: string): T | undefined;
    lookup(key: string): T;
    add(item: T, before?: T): void;
    move(item: T, before: T | undefined): void;
    remove(item: T): void;
    beginRenovation(diff?: Array<T>): LinkedListRenovation<T>;
    endRenovation(error?: unknown): LinkedListRenovation<T>;
    extractKey(item: T): string;
    static move$<T extends LinkedItem<T>>(list: LinkedList<T>, item: T, before: T | undefined): void;
    static remove$<T extends LinkedItem<T>>(list: LinkedList<T>, item: T): void;
    static removeKey$<T extends LinkedItem<T>>(list: LinkedList<T>, key: string): void;
}
export declare enum Mark {
    reaffirmed = 0,
    added = 1,
    moved = 2,
    removed = 3
}
export declare class LinkedItem<T extends LinkedItem<T>> {
    private list$;
    private next$;
    private prev$;
    private status;
    constructor();
    get list(): LinkedSubList<T> | undefined;
    get next(): T | undefined;
    get prev(): T | undefined;
    get mark(): Mark;
    get rank(): number;
    get isManagedExternally(): boolean;
    static setStatus$<T extends LinkedItem<T>>(item: T, mark: Mark, rank: number): void;
    static link$<T extends LinkedItem<T>>(list: LinkedSubList<T> | undefined, item: T, before: T | undefined): void;
    private static unlink;
}
export declare class LinkedSubList<T extends LinkedItem<T>> {
    count: number;
    first?: T;
    last?: T;
    items(after?: T): Generator<T>;
    clear(): void;
    grab(from: LinkedSubList<T>, join: boolean): void;
}
export declare class LinkedListRenovation<T extends LinkedItem<T>> {
    readonly list: LinkedList<T>;
    readonly diff: Array<T> | undefined;
    private former;
    private expected;
    private absent;
    constructor(list: LinkedList<T>, former: LinkedSubList<T>, diff?: Array<T>);
    tryLookup(key: string): T | undefined;
    tryReaffirm(key: string, resolution?: {
        isDuplicate: boolean;
    }, error?: string): T | undefined;
    thisIsAdded(item: T, before?: T): T;
    thisIsModified(item: T): void;
    thisIsMoved(item: T, before: T | undefined): void;
    thisIsRemoved(item: T): void;
    get lostItemCount(): number;
    lostItems(): Generator<T>;
}