19402070633

Committed 16 Nov 2025 07:13AM UTC coverage: 94.056% (+0.02%) from 94.037%

Build # 19402070633

Build Type

Pull #141

github

Committed by

web-flow

Commit Message

Merge 36482b5bd into 633311aca

Pull Request Pull Request #141: Encoder overhaul

Run Details

1167 of 1296 branches covered (90.05%)

Branch coverage included in aggregate %.

754 of 764 new or added lines in 49 files covered. (98.69%)

14 existing lines in 4 files now uncovered.

6698 of 7066 relevant lines covered (94.79%)

55535.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.67

/src/codec/tlsEncoder.ts

export type Encoder<T> = (t: T) => Uint8Array

export type Enc<T> = (t: T) => [number, (offset: number, buffer: ArrayBuffer) => void]

export function encode<T>(enc: Enc<T>): Encoder<T> {
  return (t: T) => {
    const [len, write] = enc(t)
    const buf = new ArrayBuffer(len)
    write(0, buf)
    return new Uint8Array(buf)
  }
}

export function composeEnc<T, U>(encT: Enc<T>, encU: Enc<U>): Enc<[T, U]> {
  return ([t, u]) => {
    const [lenT, writeT] = encT(t)
    const [lenU, writeU] = encU(u)

    return [
      lenT + lenU,
      (offset, buffer) => {
        writeT(offset, buffer)
        writeU(offset + lenT, buffer)
      },
    ]
  }
}

export function contramapEnc<T, U>(enc: Enc<T>, f: (u: U) => Readonly<T>): Enc<U> {
  return (u: U) => enc(f(u))
}

export function contramapEncs<T extends unknown[], R>(
  encoders: { [K in keyof T]: Enc<T[K]> },
  toTuple: (input: R) => T,
): Enc<R> {
  return (value: R) => {
    const values = toTuple(value)
    let totalLength = 0
    let writeTotal = (_offset: number, _buffer: ArrayBuffer) => {}
    for (let i = 0; i < encoders.length; i++) {
      const [len, write] = encoders[i]!(values[i])
      const oldFunc = writeTotal
      const currentLen = totalLength
      writeTotal = (offset: number, buffer: ArrayBuffer) => {
        oldFunc(offset, buffer)
        write(offset + currentLen, buffer)
      }
      totalLength += len
    }
    return [totalLength, writeTotal]
  }
}

export function composeEncs<T extends unknown[]>(encoders: { [K in keyof T]: Enc<T[K]> }): Enc<T> {
  return (values: T) => contramapEncs(encoders, (t) => t as T)(values)
}

export const encVoid: [number, (offset: number, buffer: ArrayBuffer) => void] = [0, () => {}]

export function contramapEncoders<T extends unknown[], R>(
  encoders: { [K in keyof T]: Encoder<T[K]> },
  toTuple: (input: R) => T,
): Encoder<R> {
  return (value: R) => {
    const values = toTuple(value)

    const encodedParts: Uint8Array[] = new Array<Uint8Array>(values.length)
    let totalLength = 0
    for (let i = 0; i < values.length; i++) {
      const encoded = encoders[i]!(values[i])
      totalLength += encoded.byteLength
      encodedParts[i] = encoded
    }

    const result = new Uint8Array(totalLength)
    let offset = 0
    for (const arr of encodedParts) {
      result.set(arr, offset)
      offset += arr.length
    }

    return result
  }
}

export function composeEncoders<T extends unknown[]>(encoders: { [K in keyof T]: Encoder<T[K]> }): Encoder<T> {
  return (values: T) => contramapEncoders(encoders, (t) => t as T)(values)
}

export function contramapEncoder<T, U>(enc: Encoder<T>, f: (u: U) => Readonly<T>): Encoder<U> {
  return (u: U) => enc(f(u))
}

export function encodeVoid<T>(): Encoder<T> {
  return () => new Uint8Array()
}

1	export type Encoder<T> = (t: T) => Uint8Array
2
3	export type Enc<T> = (t: T) => [number, (offset: number, buffer: ArrayBuffer) => void]
4
5	export function encode<T>(enc: Enc<T>): Encoder<T> {	1✔
6	return (t: T) => {	482,364✔
7	const [len, write] = enc(t)	500,661✔
8	const buf = new ArrayBuffer(len)	500,661✔
9	write(0, buf)	500,661✔
10	return new Uint8Array(buf)	500,661✔
11	}	500,661✔
12	}	482,364✔
13
14	export function composeEnc<T, U>(encT: Enc<T>, encU: Enc<U>): Enc<[T, U]> {	1✔
NEW 15	return ([t, u]) => {	×
NEW 16	const [lenT, writeT] = encT(t)	×
NEW 17	const [lenU, writeU] = encU(u)	×
18
NEW 19	return [	×
NEW 20	lenT + lenU,	×
NEW 21	(offset, buffer) => {	×
NEW 22	writeT(offset, buffer)	×
NEW 23	writeU(offset + lenT, buffer)	×
NEW 24	},	×
NEW 25	]	×
UNCOV 26	}	×
UNCOV 27	}	×
28
29	export function contramapEnc<T, U>(enc: Enc<T>, f: (u: U) => Readonly<T>): Enc<U> {	1✔
30	return (u: U) => enc(f(u))	4,759✔
31	}	4,759✔
32
33	export function contramapEncs<T extends unknown[], R>(	1✔
34	encoders: { [K in keyof T]: Enc<T[K]> },	266,253✔
35	toTuple: (input: R) => T,	266,253✔
36	): Enc<R> {	266,253✔
37	return (value: R) => {	266,253✔
38	const values = toTuple(value)	1,879,796✔
39	let totalLength = 0	1,879,796✔
40	let writeTotal = (_offset: number, _buffer: ArrayBuffer) => {}	1,879,796✔
41	for (let i = 0; i < encoders.length; i++) {	1,879,796✔
42	const [len, write] = encoders[i]!(values[i])	6,001,850✔
43	const oldFunc = writeTotal	6,001,850✔
44	const currentLen = totalLength	6,001,850✔
45	writeTotal = (offset: number, buffer: ArrayBuffer) => {	6,001,850✔
46	oldFunc(offset, buffer)	6,001,850✔
47	write(offset + currentLen, buffer)	6,001,850✔
48	}	6,001,850✔
49	totalLength += len	6,001,850✔
50	}	6,001,850✔
51	return [totalLength, writeTotal]	6,001,850✔
52	}	1,879,796✔
53	}	266,253✔
54
55	export function composeEncs<T extends unknown[]>(encoders: { [K in keyof T]: Enc<T[K]> }): Enc<T> {	1✔
56	return (values: T) => contramapEncs(encoders, (t) => t as T)(values)	23,908✔
57	}	23,908✔
58
59	export const encVoid: [number, (offset: number, buffer: ArrayBuffer) => void] = [0, () => {}]	1✔
60
61	export function contramapEncoders<T extends unknown[], R>(	1✔
62	encoders: { [K in keyof T]: Encoder<T[K]> },	11✔
63	toTuple: (input: R) => T,	11✔
64	): Encoder<R> {	11✔
65	return (value: R) => {	11✔
66	const values = toTuple(value)	11✔
67
68	const encodedParts: Uint8Array[] = new Array<Uint8Array>(values.length)	11✔
69	let totalLength = 0	11✔
70	for (let i = 0; i < values.length; i++) {	11✔
71	const encoded = encoders[i]!(values[i])	29✔
72	totalLength += encoded.byteLength	29✔
73	encodedParts[i] = encoded	29✔
74	}	29✔
75
76	const result = new Uint8Array(totalLength)	11✔
77	let offset = 0	11✔
78	for (const arr of encodedParts) {	11✔
79	result.set(arr, offset)	29✔
80	offset += arr.length	29✔
81	}	29✔
82
83	return result	11✔
84	}	11✔
85	}	11✔
86
87	export function composeEncoders<T extends unknown[]>(encoders: { [K in keyof T]: Encoder<T[K]> }): Encoder<T> {	1✔
88	return (values: T) => contramapEncoders(encoders, (t) => t as T)(values)	11✔
89	}	11✔
90
91	export function contramapEncoder<T, U>(enc: Encoder<T>, f: (u: U) => Readonly<T>): Encoder<U> {	1✔
UNCOV 92	return (u: U) => enc(f(u))	×
UNCOV 93	}	×
94
95	export function encodeVoid<T>(): Encoder<T> {	1✔
UNCOV 96	return () => new Uint8Array()	×
UNCOV 97	}	×

LukaJCB / ts-mls / 19402070633

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous