@hpx7/delta-pack/dist/helpers.d.ts

A TypeScript code generator and runtime for binary serialization based on schemas.

import { Reader } from "bin-serde";
export declare class Tracker {
    private bitsIdx;
    private dict;
    private data;
    private bits;
    private reader;
    constructor(bits?: boolean[], reader?: Reader);
    static parse(buf: Uint8Array): Tracker;
    pushString(val: string): void;
    pushInt(val: number): void;
    pushUInt(val: number): void;
    pushFloat(val: number): void;
    pushFloatQuantized(val: number, precision: number): void;
    pushBoolean(val: boolean): void;
    pushOptional<T>(val: T | undefined, innerWrite: (x: T) => void): void;
    pushArray<T>(val: T[], innerWrite: (x: T) => void): void;
    pushRecord<K, T>(val: Map<K, T>, innerKeyWrite: (x: K) => void, innerValWrite: (x: T) => void): void;
    pushStringDiff(a: string, b: string): void;
    pushIntDiff(a: number, b: number): void;
    pushUIntDiff(a: number, b: number): void;
    pushFloatDiff(a: number, b: number): void;
    pushFloatQuantizedDiff(a: number, b: number, precision: number): void;
    pushBooleanDiff(a: boolean, b: boolean): void;
    pushOptionalDiffPrimitive<T>(a: T | undefined, b: T | undefined, encode: (x: T) => void): void;
    pushOptionalDiff<T>(a: T | undefined, b: T | undefined, encode: (x: T) => void, encodeDiff: (a: T, b: T) => void): void;
    pushArrayDiff<T>(a: T[], b: T[] & {
        _dirty?: Set<number>;
    }, equals: (x: T, y: T) => boolean, encode: (x: T) => void, encodeDiff: (a: T, b: T) => void): void;
    pushRecordDiff<K, T>(a: Map<K, T>, b: Map<K, T> & {
        _dirty?: Set<K>;
    }, equals: (x: T, y: T) => boolean, encodeKey: (x: K) => void, encodeVal: (x: T) => void, encodeDiff: (a: T, b: T) => void): void;
    nextString(): string;
    nextInt(): number;
    nextUInt(): number;
    nextFloat(): number;
    nextFloatQuantized(precision: number): number;
    nextBoolean(): boolean;
    nextOptional<T>(innerRead: () => T): T | undefined;
    nextArray<T>(innerRead: () => T): T[];
    nextRecord<K, T>(innerKeyRead: () => K, innerValRead: () => T): Map<K, T>;
    nextStringDiff(a: string): string;
    nextIntDiff(a: number): number;
    nextUIntDiff(a: number): number;
    nextFloatDiff(a: number): number;
    nextFloatQuantizedDiff(a: number, precision: number): number;
    nextBooleanDiff(a: boolean): boolean;
    nextOptionalDiffPrimitive<T>(obj: T | undefined, decode: () => T): T | undefined;
    nextOptionalDiff<T>(obj: T | undefined, decode: () => T, decodeDiff: (a: T) => T): T | undefined;
    nextArrayDiff<T>(arr: T[], decode: () => T, decodeDiff: (a: T) => T): T[];
    nextRecordDiff<K, T>(obj: Map<K, T>, decodeKey: () => K, decodeVal: () => T, decodeDiff: (a: T) => T): Map<K, T>;
    toBuffer(): Uint8Array<ArrayBufferLike>;
}
export declare function parseString(x: unknown): string;
export declare function parseInt(x: unknown): number;
export declare function parseUInt(x: unknown): number;
export declare function parseFloat(x: unknown): number;
export declare function parseBoolean(x: unknown): boolean;
export declare function parseEnum<K, T extends object>(x: unknown, enumObj: T): K;
export declare function parseOptional<T>(x: unknown, innerParse: (y: unknown) => T): T | undefined;
export declare function parseArray<T>(x: unknown, innerParse: (y: unknown) => T): T[];
export declare function parseRecord<K, T>(x: unknown, innerKeyParse: (y: unknown) => K, innerValParse: (y: unknown) => T): Map<K, T>;
export declare function tryParseField<T>(parseFn: () => T, key: string): T;
export declare function equalsFloat(a: number, b: number): boolean;
export declare function equalsFloatQuantized(a: number, b: number, precision: number): boolean;
export declare function equalsOptional<T>(a: T | undefined, b: T | undefined, equals: (x: T, y: T) => boolean): boolean;
export declare function equalsArray<T>(a: T[], b: T[], equals: (x: T, y: T) => boolean): boolean;
export declare function equalsRecord<K, T>(a: Map<K, T>, b: Map<K, T>, keyEquals: (x: K, y: K) => boolean, valueEquals: (x: T, y: T) => boolean): boolean;
export declare function mapValues<T, U>(obj: Record<string, T>, fn: (value: T, key: string) => U): Record<string, U>;
export declare function mapToObject<K, V>(map: Map<K, V>, valueToObject: (x: V) => unknown): Record<string, unknown>;