@cadence-app/compiler 0.4.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,9 @@
1
+ /** Le produit de deux octets dans GF(2⁸). */
2
+ export declare function multiplyInGf256(left: number, right: number): number;
3
+ /**
4
+ * Le polynôme générateur de ce nombre de codets de correction, privé de son
5
+ * coefficient de tête — il vaut toujours un, et la division ne s'en sert pas.
6
+ */
7
+ export declare function generatorTail(degree: number): Uint8Array;
8
+ /** Les codets de correction de ce bloc de données, par division polynomiale. */
9
+ export declare function errorCorrectionFor(data: Uint8Array, tail: Uint8Array): Uint8Array;
@@ -0,0 +1,48 @@
1
+ /*
2
+ * L'arithmétique du corps fini que la norme QR fixe (ISO/IEC 18004, § 7.5) :
3
+ * GF(2⁸) réduit par x⁸ + x⁴ + x³ + x² + 1. Rien ici n'est un choix — ces
4
+ * constantes sont celles qu'un lecteur attend, et toute autre rendrait le code
5
+ * illisible par une caméra.
6
+ */
7
+ const REDUCING_POLYNOMIAL = 0x11d;
8
+ const PRIMITIVE_ELEMENT = 0x02;
9
+ /** Le produit de deux octets dans GF(2⁸). */
10
+ export function multiplyInGf256(left, right) {
11
+ let product = 0;
12
+ for (let bit = 7; bit >= 0; bit -= 1) {
13
+ product = (product << 1) ^ ((product >>> 7) * REDUCING_POLYNOMIAL);
14
+ product ^= ((right >>> bit) & 1) * left;
15
+ }
16
+ return product & 0xff;
17
+ }
18
+ /**
19
+ * Le polynôme générateur de ce nombre de codets de correction, privé de son
20
+ * coefficient de tête — il vaut toujours un, et la division ne s'en sert pas.
21
+ */
22
+ export function generatorTail(degree) {
23
+ const tail = new Uint8Array(degree);
24
+ tail[degree - 1] = 1;
25
+ let root = 1;
26
+ for (let step = 0; step < degree; step += 1) {
27
+ for (let index = 0; index < degree; index += 1) {
28
+ const scaled = multiplyInGf256(tail[index] ?? 0, root);
29
+ const carried = index + 1 < degree ? (tail[index + 1] ?? 0) : 0;
30
+ tail[index] = scaled ^ carried;
31
+ }
32
+ root = multiplyInGf256(root, PRIMITIVE_ELEMENT);
33
+ }
34
+ return tail;
35
+ }
36
+ /** Les codets de correction de ce bloc de données, par division polynomiale. */
37
+ export function errorCorrectionFor(data, tail) {
38
+ const remainder = new Uint8Array(tail.length);
39
+ for (const byte of data) {
40
+ const factor = byte ^ (remainder[0] ?? 0);
41
+ remainder.copyWithin(0, 1);
42
+ remainder[remainder.length - 1] = 0;
43
+ for (let index = 0; index < tail.length; index += 1) {
44
+ remainder[index] = (remainder[index] ?? 0) ^ multiplyInGf256(tail[index] ?? 0, factor);
45
+ }
46
+ }
47
+ return remainder;
48
+ }
@@ -0,0 +1,9 @@
1
+ /** Une matrice de QR code, ligne par ligne : `true` pour un module sombre. */
2
+ export type QrMatrix = readonly (readonly boolean[])[];
3
+ /**
4
+ * Dessine la matrice de cette version à partir de ses codets, masque compris.
5
+ *
6
+ * Les codets arrivent déjà entrelacés et complétés de leur correction : ce qui
7
+ * reste est purement géométrique.
8
+ */
9
+ export declare function drawQrMatrix(codewords: Uint8Array, version: number): QrMatrix;
@@ -0,0 +1,316 @@
1
+ import { QrEncodeError } from "./qr-error.js";
2
+ /*
3
+ * Géométrie et constantes de la norme (ISO/IEC 18004). Aucune n'est un choix :
4
+ * un lecteur les attend telles quelles.
5
+ */
6
+ const TIMING_LINE = 6;
7
+ const FINDER_RADIUS = 4;
8
+ const FINDER_LIGHT_RING = 2;
9
+ const ALIGNMENT_RADIUS = 2;
10
+ const MASK_COUNT = 8;
11
+ const FORMAT_GENERATOR = 0x537;
12
+ const FORMAT_MASK = 0x5412;
13
+ const FORMAT_BIT_COUNT = 15;
14
+ const VERSION_GENERATOR = 0x1f25;
15
+ const ERROR_LEVEL_M_BITS = 0b00;
16
+ const FIRST_VERSION_CARRYING_ITS_NUMBER = 7;
17
+ const ALIGNMENT_CENTERS = [
18
+ [],
19
+ [],
20
+ [6, 18],
21
+ [6, 22],
22
+ [6, 26],
23
+ [6, 30],
24
+ [6, 34],
25
+ [6, 22, 38],
26
+ [6, 24, 42],
27
+ [6, 26, 46],
28
+ [6, 28, 50],
29
+ ];
30
+ const RUN_PENALTY = 3;
31
+ const SHORTEST_PENALIZED_RUN = 5;
32
+ const SAME_COLOUR_BLOCK_PENALTY = 3;
33
+ const FINDER_LOOKALIKE_PENALTY = 40;
34
+ const IMBALANCE_PENALTY = 10;
35
+ const IMBALANCE_STEP = 5;
36
+ /*
37
+ * Le motif du repère de position entouré de clair : un lecteur le cherche pour
38
+ * se situer, et le rencontrer ailleurs lui fait perdre le cadrage.
39
+ */
40
+ const FINDER_LOOKALIKES = [
41
+ [1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0],
42
+ [0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1],
43
+ ];
44
+ /**
45
+ * Dessine la matrice de cette version à partir de ses codets, masque compris.
46
+ *
47
+ * Les codets arrivent déjà entrelacés et complétés de leur correction : ce qui
48
+ * reste est purement géométrique.
49
+ */
50
+ export function drawQrMatrix(codewords, version) {
51
+ const size = 17 + 4 * version;
52
+ const grid = {
53
+ size,
54
+ dark: new Uint8Array(size * size),
55
+ reserved: new Uint8Array(size * size),
56
+ };
57
+ drawFunctionPatterns(grid, version);
58
+ placeCodewords(grid, codewords);
59
+ const mask = quietestMask(grid);
60
+ applyMask(grid, mask);
61
+ drawFormatInformation(grid, mask);
62
+ return rowsOf(grid).map((line) => line.map((module) => module === 1));
63
+ }
64
+ function drawFunctionPatterns(grid, version) {
65
+ for (let index = 0; index < grid.size; index += 1) {
66
+ const dark = index % 2 === 0;
67
+ setFunctionModule(grid, TIMING_LINE, index, dark);
68
+ setFunctionModule(grid, index, TIMING_LINE, dark);
69
+ }
70
+ drawFinder(grid, 3, 3);
71
+ drawFinder(grid, 3, grid.size - 4);
72
+ drawFinder(grid, grid.size - 4, 3);
73
+ const centers = alignmentCentersFor(version);
74
+ for (let row = 0; row < centers.length; row += 1) {
75
+ for (let column = 0; column < centers.length; column += 1) {
76
+ if (isUnderFinder(row, column, centers.length)) {
77
+ continue;
78
+ }
79
+ drawAlignment(grid, centers[row] ?? 0, centers[column] ?? 0);
80
+ }
81
+ }
82
+ /* Le masque n'est pas encore choisi, et les modules de format pèsent dans le
83
+ score de chacun : les réserver dès maintenant est ce qui permet de les
84
+ redessiner huit fois sans déplacer une donnée. */
85
+ drawFormatInformation(grid, 0);
86
+ if (version >= FIRST_VERSION_CARRYING_ITS_NUMBER) {
87
+ drawVersionInformation(grid, version);
88
+ }
89
+ }
90
+ function alignmentCentersFor(version) {
91
+ const centers = ALIGNMENT_CENTERS[version];
92
+ if (centers === undefined) {
93
+ throw new QrEncodeError(`version ${version} hors de ce que cet encodeur dessine`);
94
+ }
95
+ return centers;
96
+ }
97
+ /** Les trois coins qui portent déjà un repère de position, et rien d'autre. */
98
+ function isUnderFinder(row, column, count) {
99
+ const last = count - 1;
100
+ return ((row === 0 && column === 0) || (row === 0 && column === last) || (row === last && column === 0));
101
+ }
102
+ function drawFinder(grid, centerRow, centerColumn) {
103
+ for (let rowStep = -FINDER_RADIUS; rowStep <= FINDER_RADIUS; rowStep += 1) {
104
+ for (let columnStep = -FINDER_RADIUS; columnStep <= FINDER_RADIUS; columnStep += 1) {
105
+ const ring = Math.max(Math.abs(rowStep), Math.abs(columnStep));
106
+ const row = centerRow + rowStep;
107
+ const column = centerColumn + columnStep;
108
+ if (!isInside(grid, row, column)) {
109
+ continue;
110
+ }
111
+ setFunctionModule(grid, row, column, ring !== FINDER_LIGHT_RING && ring !== FINDER_RADIUS);
112
+ }
113
+ }
114
+ }
115
+ function drawAlignment(grid, centerRow, centerColumn) {
116
+ for (let rowStep = -ALIGNMENT_RADIUS; rowStep <= ALIGNMENT_RADIUS; rowStep += 1) {
117
+ for (let columnStep = -ALIGNMENT_RADIUS; columnStep <= ALIGNMENT_RADIUS; columnStep += 1) {
118
+ const ring = Math.max(Math.abs(rowStep), Math.abs(columnStep));
119
+ setFunctionModule(grid, centerRow + rowStep, centerColumn + columnStep, ring !== 1);
120
+ }
121
+ }
122
+ }
123
+ /**
124
+ * Range les bits des codets dans les modules libres.
125
+ *
126
+ * Le parcours remonte et redescend des colonnes prises deux par deux, de la
127
+ * droite vers la gauche. La colonne de synchronisation est sautée en décalant
128
+ * la paire : sans cela, toutes les paires suivantes seraient déphasées.
129
+ */
130
+ function placeCodewords(grid, codewords) {
131
+ const bitCount = codewords.length * 8;
132
+ let bitIndex = 0;
133
+ for (let right = grid.size - 1; right >= 1; right -= 2) {
134
+ if (right === TIMING_LINE) {
135
+ right = TIMING_LINE - 1;
136
+ }
137
+ for (let step = 0; step < grid.size; step += 1) {
138
+ for (let offset = 0; offset < 2; offset += 1) {
139
+ const column = right - offset;
140
+ const upward = ((right + 1) & 2) === 0;
141
+ const row = upward ? grid.size - 1 - step : step;
142
+ if (grid.reserved[row * grid.size + column] === 1 || bitIndex >= bitCount) {
143
+ continue;
144
+ }
145
+ const byte = codewords[bitIndex >>> 3] ?? 0;
146
+ grid.dark[row * grid.size + column] = (byte >>> (7 - (bitIndex & 7))) & 1;
147
+ bitIndex += 1;
148
+ }
149
+ }
150
+ }
151
+ }
152
+ /**
153
+ * Le masque qui dérange le moins un lecteur.
154
+ *
155
+ * Les huit sont légitimes : la norme ne désigne pas de vainqueur, elle donne
156
+ * une pénalité. Le masque est appliqué deux fois pour revenir en arrière — un
157
+ * ou exclusif est sa propre réciproque.
158
+ */
159
+ function quietestMask(grid) {
160
+ let chosen = 0;
161
+ let lowest = Number.POSITIVE_INFINITY;
162
+ for (let mask = 0; mask < MASK_COUNT; mask += 1) {
163
+ applyMask(grid, mask);
164
+ drawFormatInformation(grid, mask);
165
+ const penalty = penaltyOf(grid);
166
+ if (penalty < lowest) {
167
+ lowest = penalty;
168
+ chosen = mask;
169
+ }
170
+ applyMask(grid, mask);
171
+ }
172
+ return chosen;
173
+ }
174
+ function applyMask(grid, mask) {
175
+ for (let row = 0; row < grid.size; row += 1) {
176
+ for (let column = 0; column < grid.size; column += 1) {
177
+ const cell = row * grid.size + column;
178
+ if (grid.reserved[cell] === 1 || !maskCovers(mask, row, column)) {
179
+ continue;
180
+ }
181
+ grid.dark[cell] = (grid.dark[cell] ?? 0) ^ 1;
182
+ }
183
+ }
184
+ }
185
+ function maskCovers(mask, row, column) {
186
+ switch (mask) {
187
+ case 0:
188
+ return (row + column) % 2 === 0;
189
+ case 1:
190
+ return row % 2 === 0;
191
+ case 2:
192
+ return column % 3 === 0;
193
+ case 3:
194
+ return (row + column) % 3 === 0;
195
+ case 4:
196
+ return (Math.floor(column / 3) + Math.floor(row / 2)) % 2 === 0;
197
+ case 5:
198
+ return ((row * column) % 2) + ((row * column) % 3) === 0;
199
+ case 6:
200
+ return (((row * column) % 2) + ((row * column) % 3)) % 2 === 0;
201
+ case 7:
202
+ return (((row + column) % 2) + ((row * column) % 3)) % 2 === 0;
203
+ default:
204
+ throw new QrEncodeError(`masque ${mask} inconnu`);
205
+ }
206
+ }
207
+ function penaltyOf(grid) {
208
+ const lines = [...rowsOf(grid), ...columnsOf(grid)];
209
+ let penalty = 0;
210
+ for (const line of lines) {
211
+ penalty += runPenalty(line) + finderLookalikePenalty(line);
212
+ }
213
+ return penalty + sameColourBlockPenalty(grid) + imbalancePenalty(grid);
214
+ }
215
+ function runPenalty(line) {
216
+ let penalty = 0;
217
+ let run = 1;
218
+ for (let index = 1; index <= line.length; index += 1) {
219
+ if (index < line.length && line[index] === line[index - 1]) {
220
+ run += 1;
221
+ continue;
222
+ }
223
+ if (run >= SHORTEST_PENALIZED_RUN) {
224
+ penalty += RUN_PENALTY + (run - SHORTEST_PENALIZED_RUN);
225
+ }
226
+ run = 1;
227
+ }
228
+ return penalty;
229
+ }
230
+ function finderLookalikePenalty(line) {
231
+ let penalty = 0;
232
+ for (const pattern of FINDER_LOOKALIKES) {
233
+ for (let start = 0; start + pattern.length <= line.length; start += 1) {
234
+ if (pattern.every((module, offset) => line[start + offset] === module)) {
235
+ penalty += FINDER_LOOKALIKE_PENALTY;
236
+ }
237
+ }
238
+ }
239
+ return penalty;
240
+ }
241
+ function sameColourBlockPenalty(grid) {
242
+ let penalty = 0;
243
+ for (let row = 0; row + 1 < grid.size; row += 1) {
244
+ for (let column = 0; column + 1 < grid.size; column += 1) {
245
+ const corner = grid.dark[row * grid.size + column];
246
+ const sameAcross = grid.dark[row * grid.size + column + 1] === corner;
247
+ const sameDown = grid.dark[(row + 1) * grid.size + column] === corner;
248
+ const sameDiagonal = grid.dark[(row + 1) * grid.size + column + 1] === corner;
249
+ if (sameAcross && sameDown && sameDiagonal) {
250
+ penalty += SAME_COLOUR_BLOCK_PENALTY;
251
+ }
252
+ }
253
+ }
254
+ return penalty;
255
+ }
256
+ function imbalancePenalty(grid) {
257
+ const total = grid.size * grid.size;
258
+ const dark = grid.dark.reduce((count, module) => count + module, 0);
259
+ const deviation = Math.abs((dark * 100) / total - 50);
260
+ return Math.floor(deviation / IMBALANCE_STEP) * IMBALANCE_PENALTY;
261
+ }
262
+ function drawFormatInformation(grid, mask) {
263
+ const level = (ERROR_LEVEL_M_BITS << 3) | mask;
264
+ let remainder = level;
265
+ for (let step = 0; step < 10; step += 1) {
266
+ remainder = (remainder << 1) ^ ((remainder >>> 9) * FORMAT_GENERATOR);
267
+ }
268
+ const bits = ((level << 10) | remainder) ^ FORMAT_MASK;
269
+ for (let index = 0; index <= 5; index += 1) {
270
+ setFunctionModule(grid, index, 8, bitAt(bits, index));
271
+ }
272
+ setFunctionModule(grid, 7, 8, bitAt(bits, 6));
273
+ setFunctionModule(grid, 8, 8, bitAt(bits, 7));
274
+ setFunctionModule(grid, 8, 7, bitAt(bits, 8));
275
+ for (let index = 9; index < FORMAT_BIT_COUNT; index += 1) {
276
+ setFunctionModule(grid, 8, 14 - index, bitAt(bits, index));
277
+ }
278
+ for (let index = 0; index < 8; index += 1) {
279
+ setFunctionModule(grid, 8, grid.size - 1 - index, bitAt(bits, index));
280
+ }
281
+ for (let index = 8; index < FORMAT_BIT_COUNT; index += 1) {
282
+ setFunctionModule(grid, grid.size - FORMAT_BIT_COUNT + index, 8, bitAt(bits, index));
283
+ }
284
+ setFunctionModule(grid, grid.size - 8, 8, true);
285
+ }
286
+ function drawVersionInformation(grid, version) {
287
+ let remainder = version;
288
+ for (let step = 0; step < 12; step += 1) {
289
+ remainder = (remainder << 1) ^ ((remainder >>> 11) * VERSION_GENERATOR);
290
+ }
291
+ const bits = (version << 12) | remainder;
292
+ for (let index = 0; index < 18; index += 1) {
293
+ const dark = bitAt(bits, index);
294
+ const far = grid.size - 11 + (index % 3);
295
+ const near = Math.floor(index / 3);
296
+ setFunctionModule(grid, near, far, dark);
297
+ setFunctionModule(grid, far, near, dark);
298
+ }
299
+ }
300
+ function setFunctionModule(grid, row, column, dark) {
301
+ const cell = row * grid.size + column;
302
+ grid.dark[cell] = dark ? 1 : 0;
303
+ grid.reserved[cell] = 1;
304
+ }
305
+ function isInside(grid, row, column) {
306
+ return row >= 0 && row < grid.size && column >= 0 && column < grid.size;
307
+ }
308
+ function bitAt(value, index) {
309
+ return ((value >>> index) & 1) === 1;
310
+ }
311
+ function rowsOf(grid) {
312
+ return Array.from({ length: grid.size }, (_unused, row) => Array.from({ length: grid.size }, (_also, column) => grid.dark[row * grid.size + column] ?? 0));
313
+ }
314
+ function columnsOf(grid) {
315
+ return Array.from({ length: grid.size }, (_unused, column) => Array.from({ length: grid.size }, (_also, row) => grid.dark[row * grid.size + column] ?? 0));
316
+ }
@@ -0,0 +1,19 @@
1
+ import type { QrMatrix } from './matrix.js';
2
+ export interface VersionSpec {
3
+ readonly version: number;
4
+ readonly errorCorrectionPerBlock: number;
5
+ /**
6
+ * Les codets de données de chaque bloc, les courts d'abord : c'est l'ordre
7
+ * dont dépend l'entrelacement, et donc la lecture.
8
+ */
9
+ readonly blocks: readonly number[];
10
+ }
11
+ export declare const QR_VERSIONS: readonly VersionSpec[];
12
+ /**
13
+ * Le QR code de ce texte, en mode octet et au niveau de correction M.
14
+ *
15
+ * Mode octet sans condition : les modes numérique et alphanumérique
16
+ * raccourciraient le code, mais l'alphanumérique ignore les minuscules, qu'une
17
+ * adresse porte toujours.
18
+ */
19
+ export declare function encodeQrCode(text: string): QrMatrix;
@@ -0,0 +1,131 @@
1
+ import { errorCorrectionFor, generatorTail } from "./galois.js";
2
+ import { drawQrMatrix } from "./matrix.js";
3
+ import { QrEncodeError } from "./qr-error.js";
4
+ const MODE_BYTE = 0b0100;
5
+ const MODE_BIT_COUNT = 4;
6
+ const TERMINATOR_BIT_COUNT = 4;
7
+ const LAST_VERSION_COUNTING_ON_ONE_BYTE = 9;
8
+ const SHORT_LENGTH_BITS = 8;
9
+ const LONG_LENGTH_BITS = 16;
10
+ /* Ce que la norme fait écrire quand les données n'emplissent pas la version. */
11
+ const PAD_BYTES = [0xec, 0x11];
12
+ /*
13
+ * Les dix premières versions au niveau de correction M, tel que la norme les
14
+ * tabule (ISO/IEC 18004, tableaux 13 à 22). La dixième porte 213 octets : bien
15
+ * au-delà d'une adresse de serveur de développement, et chaque version de plus
16
+ * serait une ligne de table que rien n'éprouve.
17
+ */
18
+ export const QR_VERSIONS = [
19
+ { version: 1, errorCorrectionPerBlock: 10, blocks: [16] },
20
+ { version: 2, errorCorrectionPerBlock: 16, blocks: [28] },
21
+ { version: 3, errorCorrectionPerBlock: 26, blocks: [44] },
22
+ { version: 4, errorCorrectionPerBlock: 18, blocks: [32, 32] },
23
+ { version: 5, errorCorrectionPerBlock: 24, blocks: [43, 43] },
24
+ { version: 6, errorCorrectionPerBlock: 16, blocks: [27, 27, 27, 27] },
25
+ { version: 7, errorCorrectionPerBlock: 18, blocks: [31, 31, 31, 31] },
26
+ { version: 8, errorCorrectionPerBlock: 22, blocks: [38, 38, 39, 39] },
27
+ { version: 9, errorCorrectionPerBlock: 22, blocks: [36, 36, 36, 37, 37] },
28
+ { version: 10, errorCorrectionPerBlock: 26, blocks: [43, 43, 43, 43, 44] },
29
+ ];
30
+ const LARGEST_TEXT_CAPACITY = Math.max(...QR_VERSIONS.map(textCapacityOf));
31
+ /**
32
+ * Le QR code de ce texte, en mode octet et au niveau de correction M.
33
+ *
34
+ * Mode octet sans condition : les modes numérique et alphanumérique
35
+ * raccourciraient le code, mais l'alphanumérique ignore les minuscules, qu'une
36
+ * adresse porte toujours.
37
+ */
38
+ export function encodeQrCode(text) {
39
+ const bytes = new TextEncoder().encode(text);
40
+ const spec = smallestVersionFor(bytes.length);
41
+ return drawQrMatrix(withErrorCorrection(dataCodewordsFor(bytes, spec), spec), spec.version);
42
+ }
43
+ function smallestVersionFor(byteCount) {
44
+ const spec = QR_VERSIONS.find((candidate) => byteCount <= textCapacityOf(candidate));
45
+ if (spec === undefined) {
46
+ throw new QrEncodeError(`${byteCount} octets dépassent ce que cet encodeur écrit (${LARGEST_TEXT_CAPACITY} au plus)`);
47
+ }
48
+ return spec;
49
+ }
50
+ function codewordCapacityOf(spec) {
51
+ return spec.blocks.reduce((total, block) => total + block, 0);
52
+ }
53
+ /** Les octets de texte qui restent, l'en-tête de mode et de longueur déduit. */
54
+ function textCapacityOf(spec) {
55
+ const headerBits = MODE_BIT_COUNT + lengthBitsFor(spec.version);
56
+ return Math.floor((codewordCapacityOf(spec) * 8 - headerBits) / 8);
57
+ }
58
+ function lengthBitsFor(version) {
59
+ return version <= LAST_VERSION_COUNTING_ON_ONE_BYTE ? SHORT_LENGTH_BITS : LONG_LENGTH_BITS;
60
+ }
61
+ function dataCodewordsFor(bytes, spec) {
62
+ const capacity = codewordCapacityOf(spec);
63
+ const bits = bitStreamFor(bytes, spec, capacity * 8);
64
+ const codewords = new Uint8Array(capacity);
65
+ for (let index = 0; index < bits.length; index += 1) {
66
+ if (bits[index] === 1) {
67
+ const codeword = index >>> 3;
68
+ codewords[codeword] = (codewords[codeword] ?? 0) | (0x80 >>> (index & 7));
69
+ }
70
+ }
71
+ const written = bits.length / 8;
72
+ for (let index = written; index < capacity; index += 1) {
73
+ codewords[index] = PAD_BYTES[(index - written) % PAD_BYTES.length] ?? 0;
74
+ }
75
+ return codewords;
76
+ }
77
+ function bitStreamFor(bytes, spec, room) {
78
+ const bits = [];
79
+ appendBits(bits, MODE_BYTE, MODE_BIT_COUNT);
80
+ appendBits(bits, bytes.length, lengthBitsFor(spec.version));
81
+ for (const byte of bytes) {
82
+ appendBits(bits, byte, 8);
83
+ }
84
+ appendBits(bits, 0, Math.min(TERMINATOR_BIT_COUNT, room - bits.length));
85
+ appendBits(bits, 0, (8 - (bits.length % 8)) % 8);
86
+ return bits;
87
+ }
88
+ function appendBits(bits, value, count) {
89
+ for (let bit = count - 1; bit >= 0; bit -= 1) {
90
+ bits.push((value >>> bit) & 1);
91
+ }
92
+ }
93
+ function withErrorCorrection(data, spec) {
94
+ const tail = generatorTail(spec.errorCorrectionPerBlock);
95
+ const blocks = [];
96
+ let taken = 0;
97
+ for (const length of spec.blocks) {
98
+ const chunk = data.subarray(taken, taken + length);
99
+ taken += length;
100
+ blocks.push({ data: chunk, errorCorrection: errorCorrectionFor(chunk, tail) });
101
+ }
102
+ return interleave(blocks);
103
+ }
104
+ /**
105
+ * Entrelace les blocs, données d'abord puis correction.
106
+ *
107
+ * Un dégât localisé sur l'étiquette touche alors un codet de chaque bloc plutôt
108
+ * que tout un bloc : c'est de là que vient la tolérance du format.
109
+ */
110
+ function interleave(blocks) {
111
+ const woven = [];
112
+ const longestData = Math.max(...blocks.map((block) => block.data.length));
113
+ for (let index = 0; index < longestData; index += 1) {
114
+ for (const block of blocks) {
115
+ const codeword = block.data[index];
116
+ if (codeword !== undefined) {
117
+ woven.push(codeword);
118
+ }
119
+ }
120
+ }
121
+ const errorCorrectionLength = blocks[0]?.errorCorrection.length ?? 0;
122
+ for (let index = 0; index < errorCorrectionLength; index += 1) {
123
+ for (const block of blocks) {
124
+ const codeword = block.errorCorrection[index];
125
+ if (codeword !== undefined) {
126
+ woven.push(codeword);
127
+ }
128
+ }
129
+ }
130
+ return new Uint8Array(woven);
131
+ }
@@ -0,0 +1,4 @@
1
+ /** Ce qui empêche d'écrire un QR code : capacité, version, masque. */
2
+ export declare class QrEncodeError extends Error {
3
+ constructor(message: string);
4
+ }
@@ -0,0 +1,7 @@
1
+ /** Ce qui empêche d'écrire un QR code : capacité, version, masque. */
2
+ export class QrEncodeError extends Error {
3
+ constructor(message) {
4
+ super(message);
5
+ this.name = 'QrEncodeError';
6
+ }
7
+ }
@@ -0,0 +1,8 @@
1
+ import type { QrMatrix } from './matrix.js';
2
+ /**
3
+ * Le QR code, prêt à être écrit dans un terminal.
4
+ *
5
+ * Deux lignes de la matrice par ligne de texte : l'encre porte la ligne du
6
+ * haut, le fond celle du bas.
7
+ */
8
+ export declare function renderQrForTerminal(matrix: QrMatrix): string;
@@ -0,0 +1,59 @@
1
+ /** Le silence que la norme exige autour du code, sans quoi un lecteur le rate. */
2
+ const QUIET_ZONE = 4;
3
+ /*
4
+ * Noir et blanc dits explicitement, et non laissés au thème du terminal : un
5
+ * code clair sur fond sombre est un code inversé, qu'une caméra lit mal ou pas.
6
+ */
7
+ const BLACK_INK = 30;
8
+ const WHITE_INK = 97;
9
+ const BLACK_GROUND = 40;
10
+ const WHITE_GROUND = 107;
11
+ /* Un demi-module par caractère en hauteur : le code tient dans un terminal. */
12
+ const UPPER_HALF = '▀';
13
+ const RESET = '\u001b[0m';
14
+ /**
15
+ * Le QR code, prêt à être écrit dans un terminal.
16
+ *
17
+ * Deux lignes de la matrice par ligne de texte : l'encre porte la ligne du
18
+ * haut, le fond celle du bas.
19
+ */
20
+ export function renderQrForTerminal(matrix) {
21
+ const rows = withQuietZone(matrix);
22
+ const lines = [];
23
+ for (let row = 0; row < rows.length; row += 2) {
24
+ lines.push(lineOf(rows[row] ?? [], rows[row + 1] ?? []));
25
+ }
26
+ return lines.join('\n');
27
+ }
28
+ function withQuietZone(matrix) {
29
+ const width = (matrix[0]?.length ?? 0) + 2 * QUIET_ZONE;
30
+ const silence = () => new Array(width).fill(false);
31
+ const framed = matrix.map((row) => [
32
+ ...new Array(QUIET_ZONE).fill(false),
33
+ ...row,
34
+ ...new Array(QUIET_ZONE).fill(false),
35
+ ]);
36
+ const rows = [
37
+ ...Array.from({ length: QUIET_ZONE }, silence),
38
+ ...framed,
39
+ ...Array.from({ length: QUIET_ZONE }, silence),
40
+ ];
41
+ /* Une matrice de côté impair laisse une demi-ligne : la compléter de clair
42
+ plutôt que de la perdre, sinon la zone de silence du bas est rognée. */
43
+ return rows.length % 2 === 0 ? rows : [...rows, silence()];
44
+ }
45
+ function lineOf(upper, lower) {
46
+ let line = '';
47
+ let painted = '';
48
+ for (let column = 0; column < upper.length; column += 1) {
49
+ const ink = upper[column] === true ? BLACK_INK : WHITE_INK;
50
+ const ground = lower[column] === true ? BLACK_GROUND : WHITE_GROUND;
51
+ const colours = `\u001b[${ink};${ground}m`;
52
+ if (colours !== painted) {
53
+ line += colours;
54
+ painted = colours;
55
+ }
56
+ line += UPPER_HALF;
57
+ }
58
+ return `${line}${RESET}`;
59
+ }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@cadence-app/compiler",
3
- "version": "0.4.0",
3
+ "version": "0.6.0",
4
4
  "description": "Compilation des templates en instructions, SCSS scopé, bundling",
5
5
  "keywords": [
6
6
  "compiler",
@@ -45,11 +45,11 @@
45
45
  "access": "public"
46
46
  },
47
47
  "dependencies": {
48
- "@cadence-app/bridge": "0.1.0",
48
+ "@cadence-app/bridge": "0.2.0",
49
49
  "@cadence-app/core": "0.1.0",
50
- "@cadence-app/router": "0.1.0",
51
- "@cadence-app/runtime": "0.2.0",
52
- "@cadence-app/theme": "0.2.0",
50
+ "@cadence-app/router": "0.3.0",
51
+ "@cadence-app/runtime": "0.3.0",
52
+ "@cadence-app/theme": "0.3.0",
53
53
  "esbuild": "^0.25.0",
54
54
  "jszip": "^3.10.1",
55
55
  "postcss": "^8.5.1",