enhance-data-view/dist/types/core.d.ts

Reactive DataView extension with chainable API for type-safe binary data manipulation.

/**
 * Context object received during generic type operations (read/write)
 */
export interface OperationContext {
    /** DataView instance for current operation */
    view: DataView;
    /** Byte offset for current operation */
    offset: number;
    /** Whether to use little-endian byte order */
    littleEndian?: boolean;
}
/**
 * Context object for reactive conversion operations
 */
export interface OperationContextDynamic {
    /** DataView instance for current operation */
    view: DataView;
    /** Whether to use little-endian byte order */
    littleEndian?: boolean;
    /** Offset relative to operation start position */
    localOffset: number;
    /**
     * Base offset getter for read operations
     * @remarks Supports dynamic starting positions in reactive mode
     */
    baseOffset: () => number;
    /**
     * Caches getter function for performance optimization
     * @param getter - Function to cache for subsequent reads
     */
    cacheGetter: (getter: () => any) => void;
}
/** Function signature for type definition read operations */
export type OperationGetter<T> = (this: TypeDefinition<T>, context: OperationContext) => T;
/** Function signature for type definition write operations */
export type OperationSetter<T> = (this: TypeDefinition<T>, context: OperationContext, value: T) => void;
/** Function signature for reactive object conversion */
export type OperationReactive<T> = (this: TypeDefinition<T>, context: OperationContextDynamic) => T;
/** Unique symbol identifying type definition objects */
export declare const TypeDefinitionSymbol: unique symbol;
/**
 * Describes a binary data type definition
 * @template T - JavaScript type represented by this definition
 */
export interface TypeDefinition<T> {
    /** Type identification marker */
    isTypeDefinition: typeof TypeDefinitionSymbol;
    /** Type name for debugging purposes */
    name: string;
    /** Type size in bytes */
    size: number;
    /** Alignment requirement for memory layout calculations */
    align: number;
    /** Read operation implementation */
    getter: OperationGetter<T>;
    /** Write operation implementation */
    setter: OperationSetter<T>;
    /** Reactive conversion implementation */
    reactive: OperationReactive<T>;
}
/**
 * Type guard for TypeDefinition objects
 * @param test - Value to check
 * @returns Whether the value is a valid TypeDefinition
 */
export declare function isTypeDefinition(test: any): test is TypeDefinition<any>;
/** Represents either a static value or a getter function */
export type ValueOrGetter<T> = T | (() => T);
/**
 * Reads typed data from DataView
 * @param view - Source DataView
 * @param type - Type definition
 * @param offset - Read offset in bytes
 * @param littleEndian - Byte order (default: big-endian)
 * @returns Decoded value
 * @example
 * const num = get(view, INT, 0x10, true);
 */
export declare function get<T>(view: DataView, type: TypeDefinition<T>, offset: number, littleEndian?: boolean): T;
/**
 * Reads array of typed data from DataView
 * @param view - Source DataView
 * @param type - Element type definition
 * @param offset - Starting offset in bytes
 * @param length - Number of elements to read
 * @param littleEndian - Byte order (default: big-endian)
 * @returns Array of decoded values
 * @example
 * const coords = getArray(view, FLOAT, 0x20, 3);
 */
export declare function getArray<T>(view: DataView, type: TypeDefinition<T>, offset: number, length: number, littleEndian?: boolean): Array<T>;
/**
 * Writes typed data to DataView
 * @param view - Target DataView
 * @param type - Type definition
 * @param offset - Write offset in bytes
 * @param value - Value to encode
 * @param littleEndian - Byte order (default: big-endian)
 * @example
 * set(view, FLOAT, 0x08, 3.14159);
 */
export declare function set<T>(view: DataView, type: TypeDefinition<T>, offset: number, value: T, littleEndian?: boolean): void;
/**
 * Writes array of typed data to DataView
 * @param view - Target DataView
 * @param type - Element type definition
 * @param offset - Starting offset in bytes
 * @param array - Values to encode
 * @param littleEndian - Byte order (default: big-endian)
 * @example
 * setArray(view, INT, 0x30, [1, 2, 3]);
 */
export declare function setArray<T>(view: DataView, type: TypeDefinition<T>, offset: number, array: ArrayLike<T>, littleEndian?: boolean): void;
/**
 * Converts DataView region to reactive object
 * @param view - Source DataView
 * @param type - Type definition
 * @param offset - Byte offset or offset getter
 * @param littleEndian - Byte order (default: big-endian)
 * @returns Reactive proxy object
 * @remarks Property accesses trigger automatic get/set operations
 * @example
 * const player = reactive(view, PlayerStruct, 0x100);
 * player.health = 80; // Automatically writes to DataView
 */
export declare function reactive<T>(view: DataView, type: TypeDefinition<T>, offset: ValueOrGetter<number>, littleEndian?: boolean): T;
/** Reference wrapper for reactive value types */
export interface Ref<T> {
    value: T;
}
/**
 * Creates reactive reference for value types
 * @param view - Source DataView
 * @param type - Type definition
 * @param offset - Byte offset or offset getter
 * @param littleEndian - Byte order (default: big-endian)
 * @returns Reactive reference object
 * @remarks Optimized for primitive/value type access
 * @example
 * const hp = ref(view, UINT, 0x104);
 * console.log(hp.value); // Reads from DataView
 * hp.value = 100;       // Writes to DataView
 */
export declare function ref<T>(view: DataView, type: TypeDefinition<T>, offset: ValueOrGetter<number>, littleEndian?: boolean): Ref<T>;
/**
 * Symbol for retrieving raw values from reactive objects
 * @remarks Reactive objects must implement this symbol
 */
export declare const OperationRawSymbol: unique symbol;
/**
 * Extracts raw value from reactive objects
 * @param value - Reactive proxy or raw value
 * @returns Underlying non-reactive value
 * @example
 * const raw = toRaw(reactiveObj);
 */
export declare function toRaw<T>(value: T): T;
/**
 * Creates reference for nested reactive property
 * @param target - Reactive source object
 * @param key - Property key to reference
 * @returns Reactive reference to specified property
 * @example
 * const hpRef = toRef(player, 'health');
 */
export declare function toRef<T, K extends keyof T>(target: T, key: K): Ref<T[K]>;