30915904563

Committed 04 Aug 2026 01:51PM UTC coverage: 98.358% (+0.04%) from 98.316%

Build # 30915904563

Build Type

Pull #2242

github

Committed by

web-flow

Commit Message

Merge d519175cb into e4b484cbf

Pull Request Pull Request #2242: feat: Added QR code component with encoding and rendering capabilities

Coverage Stats

6449 of 6780 branches covered (95.12%)

Branch coverage included in aggregate %.

2766 of 2787 new or added lines in 12 files covered. (99.25%)

1 existing line in 1 file now uncovered.

46078 of 46624 relevant lines covered (98.83%)

1907.55 hits per line

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

96.98

/src/components/qr-code/model/encode.ts

import type { QrEncodingMode, QrErrorCorrectionLevel } from '../types.js';
import { getDataCodewordsCount, interleaveBlocks } from './error-correction.js';

const EC_LEVEL_INDEX = { L: 0, M: 1, Q: 2, H: 3 } as const;
const ALPHANUMERIC_MAP = new Map<string, number>(
  [...'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:'].map((char, index) => [
    char,
    index,
  ])
);
const PAD_BYTES = [0xec, 0x11];
const TEXT_ENCODER = new TextEncoder();

function getAlphanumericValue(char: string): number {
  return ALPHANUMERIC_MAP.get(char) ?? -1;
}

function isNumeric(str: string): boolean {
  return /^\d+$/.test(str);
}

function isAlphanumeric(str: string): boolean {
  for (const char of str) {
    if (!ALPHANUMERIC_MAP.has(char)) {
      return false;
    }
  }
  return true;
}

function detectEncodingMode(data: string): QrEncodingMode {
  if (isNumeric(data)) return 'numeric';
  if (isAlphanumeric(data)) return 'alphanumeric';
  return 'byte';
}

function getCharacterCountBits(mode: QrEncodingMode, version: number): number {
  switch (mode) {
    case 'numeric':
      return version < 10 ? 10 : version < 27 ? 12 : 14;
    case 'alphanumeric':
      return version < 10 ? 9 : version < 27 ? 11 : 13;
    case 'byte':
      return version < 10 ? 8 : version < 27 ? 16 : 16;
    default:
      throw new Error(`Unsupported encoding mode: ${mode}`);
  }
}

const MODE_INDICATORS: Record<QrEncodingMode, number> = {
  numeric: 0b0001,
  alphanumeric: 0b0010,
  byte: 0b0100,
};

function pushBits(bits: number[], value: number, length: number): void {
  for (let i = length - 1; i >= 0; i--) {
    bits.push((value >> i) & 1);
  }
}

function encodeData(
  data: string,
  mode: QrEncodingMode,
  version: number
): number[] {
  const bits: number[] = [];
  const byteEncoded = mode === 'byte' ? TEXT_ENCODER.encode(data) : null;

  pushBits(bits, MODE_INDICATORS[mode], 4);

  const charCount = byteEncoded ? byteEncoded.length : data.length;
  pushBits(bits, charCount, getCharacterCountBits(mode, version));

  switch (mode) {
    case 'numeric':
      for (let i = 0; i < data.length; i += 3) {
        const chunk = data.slice(i, i + 3);
        const value = Number.parseInt(chunk, 10);

        if (chunk.length === 3) pushBits(bits, value, 10);
        else if (chunk.length === 2) pushBits(bits, value, 7);
        else pushBits(bits, value, 4);
      }
      break;
    case 'alphanumeric':
      for (let i = 0; i < data.length; i += 2) {
        if (i + 1 < data.length) {
          const value =
            getAlphanumericValue(data[i]) * 45 +
            getAlphanumericValue(data[i + 1]);
          pushBits(bits, value, 11);
        } else {
          pushBits(bits, getAlphanumericValue(data[i]), 6);
        }
      }
      break;
    default:
      for (const byte of byteEncoded!) {
        pushBits(bits, byte, 8);
      }
      break;
  }

  return bits;
}

function bitsToBytes(bits: number[]): number[] {
  const bytes: number[] = [];
  for (let i = 0; i < bits.length; i += 8) {
    let byte = 0;
    for (let j = 0; j < 8 && i + j < bits.length; j++) {
      byte = (byte << 1) | bits[i + j];
    }
    bytes.push(byte);
  }
  return bytes;
}

function padData(data: number[], totalBytes: number): number[] {
  const result = data.slice();

  if (result.length > totalBytes) {
    throw new Error(
      'Data exceeds maximum capacity for this version and error correction level'
    );
  }

  let padIndex = 0;
  while (result.length < totalBytes) {
    result.push(PAD_BYTES[padIndex % 2]);
    padIndex++;
  }
  return result;
}

/** Result produced by `encodeQR`. */
export type EncodeResult = {
  /** Interleaved data + ECC codewords ready for matrix placement. */
  codewords: number[];
  /** Encoding mode that was applied to the input string. */
  mode: QrEncodingMode;
  /** QR version (1–40) used for this code. */
  version: number;
  /** Numeric index of the error correction level (L=0, M=1, Q=2, H=3). */
  ecLevelIndex: number;
};

/**
 * Encodes a string into QR codewords (data + error correction), selecting the
 * smallest version that fits unless `requestedVersion` is specified.
 *
 * @throws When `data` is empty, the requested version is out of range, or the
 * data exceeds the capacity of the requested version.
 */
export function encodeQR(
  data: string,
  ecLevel: QrErrorCorrectionLevel = 'M',
  requestedVersion?: number
): EncodeResult {
  if (data.length === 0) {
    throw new Error('Data cannot be empty');
  }

  const ecIndex = EC_LEVEL_INDEX[ecLevel];
  const mode = detectEncodingMode(data);

  let version = 1;
  let bits: number[];

  if (requestedVersion != null) {
    if (requestedVersion < 1 || requestedVersion > 40) {
      throw new Error('Requested version must be between 1 and 40');
    }
    version = requestedVersion;
    bits = encodeData(data, mode, version);
    if (
      Math.ceil((bits.length + 4) / 8) > getDataCodewordsCount(version, ecIndex)
    ) {
      throw new Error(
        `Data too long for version ${version} and error correction level ${ecLevel}`
      );
    }
  } else {
    bits = [];
    for (let v = 1; v <= 40; v++) {
      const candidateBits = encodeData(data, mode, v);
      if (
        Math.ceil((candidateBits.length + 4) / 8) <=
        getDataCodewordsCount(v, ecIndex)
      ) {
        version = v;
        bits = candidateBits;
        break;
      }
    }

    // encodeData() always produces a non-empty bit sequence, so an empty
    // `bits` here means no version (1-40) could fit the data.
    if (bits.length === 0) {
      throw new Error(
        `Data too long to fit in any QR version (1-40) at error correction level '${ecLevel}'`
      );
    }
  }

  const capacity = getDataCodewordsCount(version, ecIndex);

  const maxBits = capacity * 8;
  const terminatorLength = Math.min(4, maxBits - bits.length);
  for (let i = 0; i < terminatorLength; i++) {
    bits.push(0);
  }

  while (bits.length % 8 !== 0) {
    bits.push(0);
  }

  const dataBytes = bitsToBytes(bits);
  const paddedData = padData(dataBytes, capacity);
  const codewords = interleaveBlocks(paddedData, version, ecIndex);

  return {
    codewords,
    mode,
    version,
    ecLevelIndex: ecIndex,
  };
}

1	import type { QrEncodingMode, QrErrorCorrectionLevel } from '../types.js';	9✔
2	import { getDataCodewordsCount, interleaveBlocks } from './error-correction.js';	9✔
3		9✔
4	const EC_LEVEL_INDEX = { L: 0, M: 1, Q: 2, H: 3 } as const;	9✔
5	const ALPHANUMERIC_MAP = new Map<string, number>(	9✔
6	[...'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:'].map((char, index) => [	9✔
7	char,	405✔
8	index,	405✔
9	])	9✔
10	);	9✔
11	const PAD_BYTES = [0xec, 0x11];	9✔
12	const TEXT_ENCODER = new TextEncoder();	9✔
13		9✔
14	function getAlphanumericValue(char: string): number {	217✔
15	return ALPHANUMERIC_MAP.get(char) ?? -1;	217!
16	}	217✔
17		9✔
18	function isNumeric(str: string): boolean {	95✔
19	return /^\d+$/.test(str);	95✔
20	}	95✔
21		9✔
22	function isAlphanumeric(str: string): boolean {	92✔
23	for (const char of str) {	92✔
24	if (!ALPHANUMERIC_MAP.has(char)) {	201✔
25	return false;	76✔
26	}	76✔
27	}	201✔
28	return true;	16✔
29	}	16✔
30		9✔
31	function detectEncodingMode(data: string): QrEncodingMode {	95✔
32	if (isNumeric(data)) return 'numeric';	95✔
33	if (isAlphanumeric(data)) return 'alphanumeric';	95✔
34	return 'byte';	76✔
35	}	76✔
36		9✔
37	function getCharacterCountBits(mode: QrEncodingMode, version: number): number {	154✔
38	switch (mode) {	154✔
39	case 'numeric':	154✔
40	return version < 10 ? 10 : version < 27 ? 12 : 14;	6!
41	case 'alphanumeric':	154✔
42	return version < 10 ? 9 : version < 27 ? 11 : 13;	16✔
43	case 'byte':	154✔
44	return version < 10 ? 8 : version < 27 ? 16 : 16;	132✔
45	default:	154!
NEW 46	throw new Error(`Unsupported encoding mode: ${mode}`);	×
47	}	154✔
48	}	154✔
49		9✔
50	const MODE_INDICATORS: Record<QrEncodingMode, number> = {	9✔
51	numeric: 0b0001,	9✔
52	alphanumeric: 0b0010,	9✔
53	byte: 0b0100,	9✔
54	};	9✔
55		9✔
56	function pushBits(bits: number[], value: number, length: number): void {	81,804✔
57	for (let i = length - 1; i >= 0; i--) {	81,804✔
58	bits.push((value >> i) & 1);	654,792✔
59	}	654,792✔
60	}	81,804✔
61		9✔
62	function encodeData(	154✔
63	data: string,	154✔
64	mode: QrEncodingMode,	154✔
65	version: number	154✔
66	): number[] {	154✔
67	const bits: number[] = [];	154✔
68	const byteEncoded = mode === 'byte' ? TEXT_ENCODER.encode(data) : null;	154✔
69		154✔
70	pushBits(bits, MODE_INDICATORS[mode], 4);	154✔
71		154✔
72	const charCount = byteEncoded ? byteEncoded.length : data.length;	154✔
73	pushBits(bits, charCount, getCharacterCountBits(mode, version));	154✔
74		154✔
75	switch (mode) {	154✔
76	case 'numeric':	154✔
77	for (let i = 0; i < data.length; i += 3) {	6✔
78	const chunk = data.slice(i, i + 3);	209✔
79	const value = Number.parseInt(chunk, 10);	209✔
80		209✔
81	if (chunk.length === 3) pushBits(bits, value, 10);	209✔
82	else if (chunk.length === 2) pushBits(bits, value, 7);	6✔
83	else pushBits(bits, value, 4);	1✔
84	}	209✔
85	break;	6✔
86	case 'alphanumeric':	154✔
87	for (let i = 0; i < data.length; i += 2) {	16✔
88	if (i + 1 < data.length) {	112✔
89	const value =	105✔
90	getAlphanumericValue(data[i]) * 45 +	105✔
91	getAlphanumericValue(data[i + 1]);	105✔
92	pushBits(bits, value, 11);	105✔
93	} else {	112✔
94	pushBits(bits, getAlphanumericValue(data[i]), 6);	7✔
95	}	7✔
96	}	112✔
97	break;	16✔
98	default:	154✔
99	for (const byte of byteEncoded!) {	132✔
100	pushBits(bits, byte, 8);	81,175✔
101	}	81,175✔
102	break;	132✔
103	}	154✔
104		154✔
105	return bits;	154✔
106	}	154✔
107		9✔
108	function bitsToBytes(bits: number[]): number[] {	91✔
109	const bytes: number[] = [];	91✔
110	for (let i = 0; i < bits.length; i += 8) {	91✔
111	let byte = 0;	921✔
112	for (let j = 0; j < 8 && i + j < bits.length; j++) {	921✔
113	byte = (byte << 1) \| bits[i + j];	7,368✔
114	}	7,368✔
115	bytes.push(byte);	921✔
116	}	921✔
117	return bytes;	91✔
118	}	91✔
119		9✔
120	function padData(data: number[], totalBytes: number): number[] {	91✔
121	const result = data.slice();	91✔
122		91✔
123	if (result.length > totalBytes) {	91!
NEW 124	throw new Error(	×
NEW 125	'Data exceeds maximum capacity for this version and error correction level'	×
NEW 126	);	×
NEW 127	}	×
128		91✔
129	let padIndex = 0;	91✔
130	while (result.length < totalBytes) {	91✔
131	result.push(PAD_BYTES[padIndex % 2]);	1,218✔
132	padIndex++;	1,218✔
133	}	1,218✔
134	return result;	91✔
135	}	91✔
136		9✔
137	/** Result produced by `encodeQR`. */	9✔
138	export type EncodeResult = {	9✔
139	/** Interleaved data + ECC codewords ready for matrix placement. */	9✔
140	codewords: number[];	9✔
141	/** Encoding mode that was applied to the input string. */	9✔
142	mode: QrEncodingMode;	9✔
143	/** QR version (1–40) used for this code. */	9✔
144	version: number;	9✔
145	/** Numeric index of the error correction level (L=0, M=1, Q=2, H=3). */	9✔
146	ecLevelIndex: number;	9✔
147	};	9✔
148		9✔
149	/**	9✔
150	* Encodes a string into QR codewords (data + error correction), selecting the	9✔
151	* smallest version that fits unless `requestedVersion` is specified.	9✔
152	*	9✔
153	* @throws When `data` is empty, the requested version is out of range, or the	9✔
154	* data exceeds the capacity of the requested version.	9✔
155	*/	9✔
156	export function encodeQR(	9✔
157	data: string,	96✔
158	ecLevel: QrErrorCorrectionLevel = 'M',	96✔
159	requestedVersion?: number	96✔
160	): EncodeResult {	96✔
161	if (data.length === 0) {	96✔
162	throw new Error('Data cannot be empty');	1✔
163	}	1✔
164		95✔
165	const ecIndex = EC_LEVEL_INDEX[ecLevel];	95✔
166	const mode = detectEncodingMode(data);	95✔
167		95✔
168	let version = 1;	95✔
169	let bits: number[];	95✔
170		95✔
171	if (requestedVersion != null) {	96✔
172	if (requestedVersion < 1 \|\| requestedVersion > 40) {	8✔
173	throw new Error('Requested version must be between 1 and 40');	2✔
174	}	2✔
175	version = requestedVersion;	6✔
176	bits = encodeData(data, mode, version);	6✔
177	if (	6✔
178	Math.ceil((bits.length + 4) / 8) > getDataCodewordsCount(version, ecIndex)	6✔
179	) {	8✔
180	throw new Error(	1✔
181	`Data too long for version ${version} and error correction level ${ecLevel}`	1✔
182	);	1✔
183	}	1✔
184	} else {	96✔
185	bits = [];	87✔
186	for (let v = 1; v <= 40; v++) {	87✔
187	const candidateBits = encodeData(data, mode, v);	148✔
188	if (	148✔
189	Math.ceil((candidateBits.length + 4) / 8) <=	148✔
190	getDataCodewordsCount(v, ecIndex)	148✔
191	) {	148✔
192	version = v;	86✔
193	bits = candidateBits;	86✔
194	break;	86✔
195	}	86✔
196	}	148✔
197		87✔
198	// encodeData() always produces a non-empty bit sequence, so an empty	87✔
199	// `bits` here means no version (1-40) could fit the data.	87✔
200	if (bits.length === 0) {	87✔
201	throw new Error(	1✔
202	`Data too long to fit in any QR version (1-40) at error correction level '${ecLevel}'`	1✔
203	);	1✔
204	}	1✔
205	}	87✔
206		91✔
207	const capacity = getDataCodewordsCount(version, ecIndex);	91✔
208		91✔
209	const maxBits = capacity * 8;	91✔
210	const terminatorLength = Math.min(4, maxBits - bits.length);	91✔
211	for (let i = 0; i < terminatorLength; i++) {	96✔
212	bits.push(0);	364✔
213	}	364✔
214		91✔
215	while (bits.length % 8 !== 0) {	96✔
216	bits.push(0);	39✔
217	}	39✔
218		91✔
219	const dataBytes = bitsToBytes(bits);	91✔
220	const paddedData = padData(dataBytes, capacity);	91✔
221	const codewords = interleaveBlocks(paddedData, version, ecIndex);	91✔
222		91✔
223	return {	91✔
224	codewords,	91✔
225	mode,	91✔
226	version,	91✔
227	ecLevelIndex: ecIndex,	91✔
228	};	91✔
229	}	91✔

IgniteUI / igniteui-webcomponents / 30915904563

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