@andrew_l/tl-pack 0.3.21 → 0.4.0

package/dist/_chunks/BinaryReader.d.mts

@@ -0,0 +1,481 @@
+import { Data } from "@andrew_l/toolkit";
+declare function createDictionary(values?: string[]): Dictionary;
+declare class Dictionary {
+  private _count;
+  private _wordToIndex;
+  private _words;
+  private _offset;
+  constructor(values?: string[], offset?: number);
+  clear(): void;
+  get size(): number;
+  /**
+   * Returns inserted index or nothing
+   */
+  maybeInsert(word: string): number | null;
+  getValue(index: number): string | null;
+  getIndex(value: string): number | null;
+  hasValue(value: string): boolean;
+  hasIndex(index: number): boolean;
+}
+type EncodeHandler<T = any> = (this: BinaryWriter, value: T) => void;
+type DecodeHandler<T = any> = (this: BinaryReader) => T;
+interface TLExtension<T = any> {
+  token: number;
+  encode: EncodeHandler<T>;
+  decode: DecodeHandler<T>;
+}
+declare function createExtension(token: number, {
+  encode,
+  decode
+}: {
+  encode: EncodeHandler;
+  decode: DecodeHandler;
+}): TLExtension;
+interface BinaryWriterOptions {
+  gzip?: boolean;
+  dictionary?: string[] | Dictionary;
+  extensions?: TLExtension[];
+  structures?: Structure.Constructor[];
+}
+declare class BinaryWriter {
+  private withGzip;
+  private target;
+  private dictionary;
+  private dictionaryExtended;
+  private extensions;
+  private structures;
+  private _last;
+  private offsetChecksum;
+  private _repeat?;
+  offset: number;
+  constructor({
+    gzip,
+    dictionary,
+    extensions,
+    structures
+  }?: BinaryWriterOptions);
+  /**
+   * Reset internal state
+   */
+  reset(): this;
+  allocate(size: number): this;
+  private makeRoom;
+  get safeEnd(): number;
+  getBuffer(): Uint8Array;
+  writeByte(value: number): this;
+  writeBool(value: boolean): this;
+  writeNull(): this;
+  writeInt64(value: number | bigint, signed?: boolean): this;
+  writeInt32(value: number, signed?: boolean): this;
+  writeInt16(value: number, signed?: boolean): this;
+  writeInt8(value: number, signed?: boolean): this;
+  writeFloat(value: number): this;
+  writeDouble(value: number): this;
+  writeDate(value: number | Date): this;
+  writeString(value: string): this;
+  writeChecksum(withConstructor?: boolean): this;
+  writeBytes(value: Uint8Array): this;
+  writeLength(value: number): this;
+  writeVector(value: Array<any>): this;
+  writeMap(object: Record<string, any>): this;
+  wireDictionary(value: string): this;
+  writeStructure(value: Structure): this;
+  writeGzip(value: Uint8Array | ArrayBuffer): this;
+  encode(value: any): Uint8Array;
+  startDynamicVector(): this;
+  endDynamicVector(): this;
+  private _writeCustom;
+  writeObject(value: any): this;
+  writeObjectGzip(value: any): this;
+  private writeCore;
+  private writeRepeat;
+}
+declare enum CORE_TYPES {
+  None = 0,
+  Binary = 1,
+  BoolFalse = 2,
+  BoolTrue = 3,
+  Null = 4,
+  Date = 5,
+  Vector = 6,
+  VectorDynamic = 7,
+  Int64 = 22,
+  Int32 = 8,
+  Int16 = 9,
+  Int8 = 10,
+  UInt64 = 23,
+  UInt32 = 11,
+  UInt16 = 12,
+  UInt8 = 13,
+  Float = 14,
+  Double = 15,
+  Map = 16,
+  DictValue = 17,
+  DictIndex = 18,
+  String = 19,
+  Repeat = 20,
+  Checksum = 21,
+  GZIP = 25,
+  Structure = 26
+}
+declare const MAX_BUFFER_SIZE = 2144337920;
+interface DefineStructureOptions<Props extends Structure.ObjectPropsOptions> {
+  /**
+   * Unique name of binary structure
+   */
+  readonly name: string;
+  /**
+   * Version of binary structure
+   */
+  readonly version: number;
+  /**
+   * Binary structure properties
+   */
+  readonly properties: Props;
+  /**
+   * Write checksum to verify decoded data
+   * @default false
+   */
+  readonly checksum?: boolean;
+}
+/**
+ * Create binary structure definition with type safety and performance optimization
+ *
+ * @example
+ * // Define a user structure
+ * const User = defineStructure({
+ *   name: 'User',
+ *   version: 1,
+ *   checksum: true,
+ *   properties: {
+ *     id: { type: Number, required: true },
+ *     name: { type: String, required: true },
+ *     email: { type: String, required: false },
+ *     isActive: { type: Boolean, required: true },
+ *     createdAt: { type: Date, required: true },
+ *     tags: { type: Array, required: false }
+ *   }
+ * });
+ *
+ * // Create and serialize a user
+ * const user = new User({
+ *   id: 123,
+ *   name: 'John Doe',
+ *   email: 'john@example.com',
+ *   isActive: true,
+ *   createdAt: new Date(),
+ *   tags: ['admin', 'verified']
+ * });
+ *
+ * const buffer = user.toBuffer();
+ * const restored = User.fromBuffer(buffer);
+ *
+ * @example
+ * // Define nested structures
+ * const Address = defineStructure({
+ *   name: 'Address',
+ *   version: 1,
+ *   properties: {
+ *     street: { type: String, required: true },
+ *     city: { type: String, required: true },
+ *     zipCode: { type: String, required: true }
+ *   }
+ * });
+ *
+ * const Person = defineStructure({
+ *   name: 'Person',
+ *   version: 1,
+ *   properties: {
+ *     name: { type: String, required: true },
+ *     address: { type: Address, required: false }
+ *   }
+ * });
+ *
+ * @example
+ * // Using with complex data types
+ * const GameState = defineStructure({
+ *   name: 'GameState',
+ *   version: 2,
+ *   checksum: true,
+ *   properties: {
+ *     playerData: { type: Object, required: true },      // Untrusted data
+ *     screenshot: { type: Uint8Array, required: false }, // Binary data
+ *     timestamp: { type: Date, required: true },
+ *     metadata: { type: Object, required: false }
+ *   }
+ * });
+ *
+ * @group Main
+ */
+declare function defineStructure<PropsOptions extends Structure.ObjectPropsOptions, T extends Data = Structure.ExtractPropTypes<PropsOptions>>({
+  name,
+  properties,
+  version,
+  checksum
+}: DefineStructureOptions<PropsOptions>): Structure.Constructor<T>;
+declare class Structure<T extends Data = Data> implements Structure.Structure<T> {
+  readonly value: T;
+  constructor(value: T);
+  toBuffer(options?: BinaryWriterOptions): Uint8Array;
+  static fromBuffer(buffer: Uint8Array, options?: BinaryReaderOptions): Data;
+  static readonly estimatedSizeBytes: number;
+  static readonly structures: Structure.Constructor[];
+  static readonly extension: TLExtension;
+}
+declare namespace Structure {
+  export interface Options<T extends Data = Data> {
+    readonly encode: EncodeHandler<T>;
+    readonly decode: DecodeHandler<T>;
+  }
+  export interface Structure<T extends Data = Data> {
+    /**
+     * The structured data value
+     * @type {T}
+     * @readonly
+     *
+     * @example
+     * const user = new UserStruct({ id: 1, name: 'Alice' });
+     * console.log(user.value.name); // 'Alice'
+     */
+    readonly value: T;
+    /**
+     * Serializes the structure to a binary buffer
+     *
+     * @param {BinaryWriterOptions} [options] - Writer configuration options
+     * @returns {Uint8Array} Serialized binary data
+     *
+     * @example
+     * const user = new User({ id: 1, name: 'Alice' });
+     * const buffer = user.toBuffer();
+     * console.log(buffer.length); // Size in bytes
+     *
+     * @example
+     * // With custom writer options
+     * const buffer = user.toBuffer({
+     *   initialSize: 1024,
+     *   growthFactor: 2
+     * });
+     */
+    toBuffer(options?: BinaryWriterOptions): Uint8Array;
+  }
+  /**
+   * Base Structure class for binary serialization with type safety
+   *
+   * @template T - Data type extending Data interface
+   *
+   * @example
+   * // Direct usage (not recommended, use defineStructure instead)
+   * class CustomStruct extends Structure<{id: number, name: string}> {
+   *   // Custom implementation
+   * }
+   *
+   * @example
+   * // Typical usage through defineStructure
+   * const MyStruct = defineStructure({
+   *   name: 'MyStruct',
+   *   version: 1,
+   *   properties: { id: { type: Number, required: true } }
+   * });
+   *
+   * const instance = new MyStruct({ id: 42 });
+   * console.log(instance.value.id); // 42
+   */
+  export interface Constructor<T extends Data = any> {
+    /**
+     * Creates a new Structure instance
+     *
+     * @param {T} value - The data to structure
+     *
+     * @example
+     * const data = { id: 123, name: 'Test' };
+     * const struct = new MyStructure(data);
+     */
+    new (value: T): Structure<T>;
+    /**
+     * Deserializes a structure from a binary buffer
+     *
+     * @param {Uint8Array} buffer - Binary data to deserialize
+     * @param {BinaryReaderOptions} [options] - Reader configuration options
+     * @returns {Data} Deserialized structure data
+     *
+     * @example
+     * const buffer = user.toBuffer();
+     * const restored = User.fromBuffer(buffer);
+     * console.log(restored.id); // Original user ID
+     */
+    fromBuffer(buffer: Uint8Array, options?: BinaryReaderOptions): T;
+    /**
+     * Estimated size of bytes
+     */
+    readonly estimatedSizeBytes: number;
+    /**
+     * Nested structures defining encoding/decoding behavior
+     */
+    readonly structures: Constructor[];
+    /**
+     * Structure extension defining encoding/decoding behavior
+     */
+    readonly extension: TLExtension;
+  }
+  type PropConstructor<T = any> = {
+    new (...args: any[]): T & {};
+  } | {
+    (): T;
+  } | PropMethod<T>;
+  type PropMethod<T, TConstructor = any> = [T] extends [((...args: any) => any) | undefined] ? {
+    new (): TConstructor;
+    (): T;
+    readonly prototype: TConstructor;
+  } : never;
+  type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+  type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
+    required: true;
+  } ? K : never }[keyof T];
+  type Prop<T> = PropOptions<T> | PropType<T>;
+  type CoreInt = CORE_TYPES.Int8 | CORE_TYPES.Int16 | CORE_TYPES.Int32 | CORE_TYPES.UInt8 | CORE_TYPES.UInt16 | CORE_TYPES.UInt32 | CORE_TYPES.Float | CORE_TYPES.Double;
+  type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? any : null : [T] extends [{
+    type: null;
+  }] ? any : [T] extends [{
+    type: [null];
+  }] ? any[] : [T] extends [{
+    type: ObjectConstructor | CORE_TYPES.Map;
+  }] ? Record<string, any> : [T] extends [{
+    type: CoreInt;
+  }] ? number : [T] extends [{
+    type: CORE_TYPES.String;
+  }] ? string : [T] extends [{
+    type: CORE_TYPES.Vector;
+  }] ? unknown[] : [T] extends [{
+    type: CORE_TYPES.Binary;
+  }] ? Uint8Array : [T] extends [{
+    type: BooleanConstructor;
+  }] ? boolean : [T] extends [{
+    type: DateConstructor | CORE_TYPES.Date;
+  }] ? Date : [T] extends [{
+    type: CORE_TYPES.UInt64 | CORE_TYPES.Int64;
+  }] ? bigint : [T] extends [{
+    type: Constructor<infer U>;
+  }] ? U : [T] extends [{
+    type: [infer U];
+  }] ? U extends DateConstructor ? Date[] : U extends Constructor<infer V> ? V[] : InferPropType<U, false>[] : [T] extends [{
+    type: (infer U)[];
+  }] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [T] extends [Prop<infer V>] ? V : T;
+  export type ObjectPropsOptions<P = Data> = { readonly [K in keyof P]: PropOptions<P[K]> };
+  export interface PropOptions<T = any> {
+    type: PropType<T> | null | [null];
+    required?: boolean;
+  }
+  export type PropType<T> = PropConstructor<T> | [PropConstructor<T>] | CORE_TYPES | [CORE_TYPES];
+  export type ExtractType<T extends Constructor> = T extends Constructor<infer U> ? U : never;
+  export type ExtractPropTypes<O> = { [K in keyof Pick<O, RequiredKeys<O>>]: O[K] extends {
+    default: any;
+  } ? Exclude<InferPropType<O[K]>, undefined> : InferPropType<O[K]> } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]> | null };
+  export {};
+}
+interface BinaryReaderOptions {
+  dictionary?: string[] | Dictionary;
+  extensions?: TLExtension[];
+  structures?: Structure.Constructor[];
+}
+declare class BinaryReader {
+  private target;
+  private _last?;
+  private _lastObject?;
+  private dictionary?;
+  private dictionaryExtended;
+  private extensions;
+  private structures;
+  private _repeat?;
+  private _checksumOffset;
+  offset: number;
+  length: number;
+  /**
+   * Small utility class to read binary data.
+   */
+  constructor(data: Uint8Array, {
+    dictionary,
+    extensions,
+    structures
+  }?: BinaryReaderOptions);
+  readByte(): number;
+  readInt64(signed?: boolean): bigint;
+  readInt32(signed?: boolean): number;
+  readInt16(signed?: boolean): number;
+  readInt8(signed?: boolean): number;
+  /**
+   * Reads a real floating point (4 bytes) value.
+   * @returns {number}
+   */
+  readFloat(): number;
+  /**
+   * Reads a real floating point (8 bytes) value.
+   */
+  readDouble(): number;
+  /**
+   * Throws error if provided length cannot be read from buffer
+   * @param length {number}
+   */
+  assertRead(length: number): void;
+  assertConstructor(constructorId: CORE_TYPES): void;
+  /**
+   * Gets the byte array representing the current buffer as a whole.
+   */
+  getBuffer(): Uint8Array;
+  readNull(): null;
+  readLength(): number;
+  readAll(): any[];
+  readBytes(): Uint8Array;
+  /**
+   * Reads encoded string.
+   */
+  readString(): string;
+  /**
+   * Reads a boolean value.
+   */
+  readBool(): boolean;
+  /**
+   * Reads and converts Unix time
+   * into a Javascript {Date} object.
+   */
+  readDate(): Date;
+  readStructure<T extends Data = Data>(checkConstructor?: boolean): T;
+  /**
+   * Reads a object.
+   */
+  readObject(): any;
+  readObjectGzip(): any;
+  readGzip(): any;
+  private readCore;
+  getDictionaryValue(index: number): string | null;
+  readDictionary(): null | string;
+  readMap(checkConstructor?: boolean): Record<string, any>;
+  decode<T = any>(value: Uint8Array): T;
+  /**
+   * Reads a vector (a list) of objects.
+   */
+  readVector<T = any>(checkConstructor?: boolean): T[];
+  /**
+   * Reads a vector (a list) of objects.
+   */
+  readVectorDynamic<T>(checkConstructor?: boolean): T[];
+  readChecksum(checkConstructor?: boolean): void;
+  /**
+   * Tells the current position on the stream.
+   */
+  tellPosition(): number;
+  /**
+   * Sets the current position on the stream.
+   */
+  setPosition(position: number): void;
+  /**
+   * Seeks the stream position given an offset from the current position.
+   * The offset may be negative.
+   */
+  seek(offset: number): void;
+  /**
+   * Sets the current buffer and reset initial state.
+   */
+  reset(data?: Uint8Array): void;
+}
+export { BinaryReader, BinaryReaderOptions, BinaryWriter, BinaryWriterOptions, CORE_TYPES, DecodeHandler, DefineStructureOptions, EncodeHandler, MAX_BUFFER_SIZE, Structure, TLExtension, createDictionary, createExtension, defineStructure };
+//# sourceMappingURL=BinaryReader.d.mts.map

package/dist/_chunks/BinaryReader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryReader.d.mts","names":["values","Dictionary","_count","_wordToIndex","_words","_offset","constructor","offset","clear","size","maybeInsert","word","getValue","index","getIndex","value","hasValue","hasIndex","T","BinaryWriter","this","value","BinaryReader","token","encode","EncodeHandler","decode","DecodeHandler","TLExtension","gzip","dictionary","Dictionary","extensions","TLExtension","structures","Structure","Constructor","withGzip","target","dictionaryExtended","_last","offsetChecksum","_repeat","offset","constructor","BinaryWriterOptions","reset","allocate","size","makeRoom","safeEnd","getBuffer","Uint8Array","writeByte","value","writeBool","writeNull","writeInt64","signed","writeInt32","writeInt16","writeInt8","writeFloat","writeDouble","writeDate","Date","writeString","writeChecksum","withConstructor","writeBytes","writeLength","writeVector","Array","writeMap","Record","object","wireDictionary","writeStructure","writeGzip","ArrayBuffer","encode","startDynamicVector","endDynamicVector","_writeCustom","writeObject","writeObjectGzip","writeCore","writeRepeat","None","Binary","BoolFalse","BoolTrue","Null","Date","Vector","VectorDynamic","Int64","Int32","Int16","Int8","UInt64","UInt32","UInt16","UInt8","Float","Double","Map","DictValue","DictIndex","String","Repeat","Checksum","GZIP","Structure","Props","Structure","ObjectPropsOptions","name","version","properties","checksum","PropsOptions","T","Data","ExtractPropTypes","DefineStructureOptions","Constructor","value","constructor","toBuffer","BinaryWriterOptions","options","Uint8Array","fromBuffer","buffer","BinaryReaderOptions","estimatedSizeBytes","structures","extension","TLExtension","Options","encode","EncodeHandler","decode","DecodeHandler","PropConstructor","args","PropMethod","TConstructor","prototype","OptionalKeys","Exclude","RequiredKeys","K","required","Prop","PropOptions","PropType","CoreInt","CORE_TYPES","Int8","Int16","Int32","UInt8","UInt16","UInt32","Float","Double","InferPropType","NullAsAny","type","ObjectConstructor","Map","Record","String","Vector","Binary","BooleanConstructor","DateConstructor","Date","UInt64","Int64","U","V","P","ExtractType","O","Pick","default","dictionary","Dictionary","extensions","TLExtension","structures","Structure","Constructor","target","_last","_lastObject","dictionaryExtended","_repeat","_checksumOffset","offset","length","constructor","Uint8Array","data","BinaryReaderOptions","readByte","readInt64","signed","readInt32","readInt16","readInt8","readFloat","readDouble","assertRead","assertConstructor","CORE_TYPES","constructorId","getBuffer","readNull","readLength","readAll","readBytes","readString","readBool","readDate","Date","readStructure","T","Data","checkConstructor","readObject","readObjectGzip","readGzip","readCore","getDictionaryValue","index","readDictionary","readMap","Record","decode","value","readVector","readVectorDynamic","readChecksum","tellPosition","setPosition","position","seek","reset"],"sources":["../../src/dictionary.d.ts","../../src/extension.d.ts","../../src/BinaryWriter.d.ts","../../src/constants.d.ts","../../src/Structure.d.ts","../../src/BinaryReader.d.ts"],"mappings":"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"}