enhance-data-view/dist/types/define-primitive.d.ts

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

import type { TypeDefinition, OperationGetter, OperationSetter, OperationReactive } from "./core";
/**
 * Immutable primitive type definition (frozen state)
 * @template T - JavaScript type represented by this primitive
 */
export interface PrimitiveDefinitionFreezed<T> extends TypeDefinition<T> {
    /**
     * Creates a mutable clone of the type definition
     * @param name - Optional new name for the cloned definition
     * @returns New mutable primitive type definition
     * @example
     * const cloned = frozenType.clone('MyRenamedType');
     */
    clone(name?: string): PrimitiveDefinition<T>;
}
/**
 * Mutable primitive type definition with chainable configuration
 * @template T - JavaScript type represented by this primitive
 * @remarks Use chainable methods to configure properties before freezing
 */
export interface PrimitiveDefinition<T> extends PrimitiveDefinitionFreezed<T> {
    /**
     * Sets the type name (for debugging/identification)
     * @param name - New name for the type
     * @returns Current instance for chaining
     * @example
     * .setName('ColorRGBA')
     */
    setName(name?: string): PrimitiveDefinition<T>;
    /**
     * Sets the byte size of the type
     * @param size - Size in bytes (default: 0)
     * @returns Current instance for chaining
     * @example
     * .setSize(4)
     */
    setSize(size?: number): PrimitiveDefinition<T>;
    /**
     * Sets the memory alignment requirement
     * @param align - Alignment value (default: 1)
     * @returns Current instance for chaining
     * @example
     * .setAlign(4) // DWORD alignment
     */
    setAlign(align?: number): PrimitiveDefinition<T>;
    /**
     * Sets the read operation implementation
     * @param getter - Read function (default: throws error)
     * @returns Current instance for chaining
     * @example
     * .setGetter(ctx => ctx.view.getUint32(ctx.offset))
     */
    setGetter(getter?: OperationGetter<T>): PrimitiveDefinition<T>;
    /**
     * Sets the write operation implementation
     * @param setter - Write function (default: throws error)
     * @returns Current instance for chaining
     * @example
     * .setSetter((ctx, value) => ctx.view.setUint32(ctx.offset, value))
     */
    setSetter(setter?: OperationSetter<T>): PrimitiveDefinition<T>;
    /**
     * Sets the reactive conversion implementation
     * @param reactive - Reactive converter (default: basic getter-based)
     * @returns Current instance for chaining
     * @example
     * .setReactive(ctx => createReactiveProxy(...))
     */
    setReactive(reactive?: OperationReactive<T>): PrimitiveDefinition<T>;
    /**
     * Freezes the type definition to prevent modification
     * @returns Immutable version of the type definition
     * @remarks
     * - Improves performance by preventing runtime changes
     * - Should be called after final configuration
     * @example
     * const finalType = mutableType.freeze();
     */
    freeze(): PrimitiveDefinitionFreezed<T>;
}
/**
 * Creates a configurable primitive type definition
 * @param name - Initial type name (optional)
 * @returns Mutable primitive type definition
 * @remarks
 * - Start with this to define custom binary types
 * - Chain configuration methods before freezing
 * @example
 * const Float32 = definePrimitive<number>('float32')
 *   .setSize(4)
 *   .setGetter(ctx => ctx.view.getFloat32(ctx.offset, ctx.littleEndian))
 *   .setSetter((ctx, value) => ctx.view.setFloat32(ctx.offset, value, ctx.littleEndian))
 *   .freeze();
 */
export declare function definePrimitive<T>(name?: string): PrimitiveDefinition<T>;