@r2digisolutions/components 0.24.2 → 0.24.3
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.
- package/dist/components/organisms/AuthShell/AuthShell.stories.d.ts +1 -1
- package/dist/components/organisms/AuthShell/AuthShell.stories.js +1 -1
- package/dist/components/organisms/AuthShell/AuthShell.svelte +5 -15
- package/dist/components/organisms/AuthShell/AuthShell.svelte.d.ts +4 -1
- package/dist/components/organisms/AuthShell/AuthShellStory.svelte +1 -1
- package/dist/components/templates/AuthTemplate/AuthTemplate.svelte +1 -1
- package/dist/utils/qr.d.ts +8 -5
- package/dist/utils/qr.js +309 -223
- package/package.json +1 -1
|
@@ -22,7 +22,10 @@
|
|
|
22
22
|
fillParent?: boolean;
|
|
23
23
|
/** Desktop marketing panel placement */
|
|
24
24
|
asideSide?: AuthAsideSide;
|
|
25
|
-
/**
|
|
25
|
+
/**
|
|
26
|
+
* Compact gradient hero above the form on small screens.
|
|
27
|
+
* Off by default: mobile shows only the form column (the card carries the brand).
|
|
28
|
+
*/
|
|
26
29
|
mobileHero?: boolean;
|
|
27
30
|
highlights?: string[];
|
|
28
31
|
class?: string;
|
|
@@ -41,7 +44,7 @@
|
|
|
41
44
|
fullHeight = true,
|
|
42
45
|
fillParent = false,
|
|
43
46
|
asideSide = 'left',
|
|
44
|
-
mobileHero =
|
|
47
|
+
mobileHero = false,
|
|
45
48
|
highlights = [
|
|
46
49
|
'Reusable atoms, molecules, and page templates',
|
|
47
50
|
'Consistent tokens across product surfaces',
|
|
@@ -174,19 +177,6 @@
|
|
|
174
177
|
<div class="lg:hidden shrink-0">
|
|
175
178
|
{@render marketingPanel(true)}
|
|
176
179
|
</div>
|
|
177
|
-
{:else}
|
|
178
|
-
<div class="px-5 pt-6 lg:hidden shrink-0 text-center">
|
|
179
|
-
<BrandMark
|
|
180
|
-
name={brand}
|
|
181
|
-
{logoSrc}
|
|
182
|
-
{monochrome}
|
|
183
|
-
href={brandHref}
|
|
184
|
-
showName
|
|
185
|
-
size="md"
|
|
186
|
-
class="justify-center"
|
|
187
|
-
/>
|
|
188
|
-
<p class="mt-2 text-sm text-muted">{tagline}</p>
|
|
189
|
-
</div>
|
|
190
180
|
{/if}
|
|
191
181
|
|
|
192
182
|
<!-- Form column: true center in remaining space -->
|
|
@@ -17,7 +17,10 @@ interface AuthShellProps {
|
|
|
17
17
|
fillParent?: boolean;
|
|
18
18
|
/** Desktop marketing panel placement */
|
|
19
19
|
asideSide?: AuthAsideSide;
|
|
20
|
-
/**
|
|
20
|
+
/**
|
|
21
|
+
* Compact gradient hero above the form on small screens.
|
|
22
|
+
* Off by default: mobile shows only the form column (the card carries the brand).
|
|
23
|
+
*/
|
|
21
24
|
mobileHero?: boolean;
|
|
22
25
|
highlights?: string[];
|
|
23
26
|
class?: string;
|
|
@@ -11,7 +11,7 @@
|
|
|
11
11
|
headline = 'Sign in to continue',
|
|
12
12
|
fullHeight = true,
|
|
13
13
|
asideSide = 'left' as AuthAsideSide,
|
|
14
|
-
mobileHero =
|
|
14
|
+
mobileHero = false,
|
|
15
15
|
formVariant = 'card' as LoginFormVariant,
|
|
16
16
|
formAlign = 'center' as 'center' | 'start',
|
|
17
17
|
preview = 'desktop' as 'desktop' | 'mobile' | 'compact'
|
package/dist/utils/qr.d.ts
CHANGED
|
@@ -1,13 +1,16 @@
|
|
|
1
1
|
/**
|
|
2
|
-
*
|
|
3
|
-
*
|
|
2
|
+
* QR Code encoder (byte mode, ECC level M, versions 1–40). No external deps.
|
|
3
|
+
* Follows ISO/IEC 18004: block interleaving, version info, format info and
|
|
4
|
+
* mask selection by penalty score, so the output is scannable by any reader.
|
|
4
5
|
*/
|
|
6
|
+
type Matrix = boolean[][];
|
|
5
7
|
/** Returns a square boolean matrix (true = dark module). */
|
|
6
|
-
export declare function encodeQR(text: string):
|
|
7
|
-
export declare function qrToSvgPath(matrix:
|
|
8
|
+
export declare function encodeQR(text: string): Matrix;
|
|
9
|
+
export declare function qrToSvgPath(matrix: Matrix, cell?: number): string;
|
|
8
10
|
/**
|
|
9
11
|
* Clears a centered square so a logo can sit in empty modules
|
|
10
12
|
* instead of covering data. `ratio` is hole size relative to matrix (0–1).
|
|
11
13
|
* Returns a shallow-cloned matrix.
|
|
12
14
|
*/
|
|
13
|
-
export declare function punchLogoHole(matrix:
|
|
15
|
+
export declare function punchLogoHole(matrix: Matrix, ratio?: number): Matrix;
|
|
16
|
+
export {};
|
package/dist/utils/qr.js
CHANGED
|
@@ -1,268 +1,354 @@
|
|
|
1
1
|
/**
|
|
2
|
-
*
|
|
3
|
-
*
|
|
2
|
+
* QR Code encoder (byte mode, ECC level M, versions 1–40). No external deps.
|
|
3
|
+
* Follows ISO/IEC 18004: block interleaving, version info, format info and
|
|
4
|
+
* mask selection by penalty score, so the output is scannable by any reader.
|
|
4
5
|
*/
|
|
5
|
-
const
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
8
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
1: 16,
|
|
19
|
-
2: 28,
|
|
20
|
-
3: 44,
|
|
21
|
-
4: 64,
|
|
22
|
-
5: 86,
|
|
23
|
-
6: 108,
|
|
24
|
-
7: 124,
|
|
25
|
-
8: 154,
|
|
26
|
-
9: 182,
|
|
27
|
-
10: 216
|
|
28
|
-
};
|
|
29
|
-
const ALIGNMENT = {
|
|
30
|
-
1: [],
|
|
31
|
-
2: [6, 18],
|
|
32
|
-
3: [6, 22],
|
|
33
|
-
4: [6, 26],
|
|
34
|
-
5: [6, 30],
|
|
35
|
-
6: [6, 34],
|
|
36
|
-
7: [6, 22, 38],
|
|
37
|
-
8: [6, 24, 42],
|
|
38
|
-
9: [6, 26, 46],
|
|
39
|
-
10: [6, 28, 50]
|
|
40
|
-
};
|
|
41
|
-
function gfMul(x, y) {
|
|
42
|
-
if (x === 0 || y === 0)
|
|
43
|
-
return 0;
|
|
44
|
-
return EXP[(LOG[x] + LOG[y]) % 255];
|
|
6
|
+
const ECL_M_FORMAT_BITS = 0;
|
|
7
|
+
/** ECC codewords per block, level M, versions 1..40. */
|
|
8
|
+
const ECC_PER_BLOCK_M = [
|
|
9
|
+
10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28,
|
|
10
|
+
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28
|
|
11
|
+
];
|
|
12
|
+
/** Number of ECC blocks, level M, versions 1..40. */
|
|
13
|
+
const NUM_BLOCKS_M = [
|
|
14
|
+
1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26,
|
|
15
|
+
28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49
|
|
16
|
+
];
|
|
17
|
+
function sizeOf(version) {
|
|
18
|
+
return version * 4 + 17;
|
|
45
19
|
}
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
(
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
x <<= 1;
|
|
54
|
-
if (x & 0x100)
|
|
55
|
-
x ^= 0x11d;
|
|
20
|
+
function numRawDataModules(version) {
|
|
21
|
+
let result = (16 * version + 128) * version + 64;
|
|
22
|
+
if (version >= 2) {
|
|
23
|
+
const numAlign = Math.floor(version / 7) + 2;
|
|
24
|
+
result -= (25 * numAlign - 10) * numAlign - 55;
|
|
25
|
+
if (version >= 7)
|
|
26
|
+
result -= 36;
|
|
56
27
|
}
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
28
|
+
return result;
|
|
29
|
+
}
|
|
30
|
+
function numDataCodewords(version) {
|
|
31
|
+
return (Math.floor(numRawDataModules(version) / 8) -
|
|
32
|
+
ECC_PER_BLOCK_M[version - 1] * NUM_BLOCKS_M[version - 1]);
|
|
33
|
+
}
|
|
34
|
+
function charCountBits(version) {
|
|
35
|
+
return version <= 9 ? 8 : 16;
|
|
36
|
+
}
|
|
37
|
+
function chooseVersion(byteLen) {
|
|
38
|
+
for (let v = 1; v <= 40; v++) {
|
|
39
|
+
const bitsNeeded = 4 + charCountBits(v) + byteLen * 8;
|
|
40
|
+
if (bitsNeeded <= numDataCodewords(v) * 8)
|
|
41
|
+
return v;
|
|
42
|
+
}
|
|
43
|
+
throw new Error('QR payload too long');
|
|
44
|
+
}
|
|
45
|
+
function alignmentPositions(version) {
|
|
46
|
+
if (version === 1)
|
|
47
|
+
return [];
|
|
48
|
+
const numAlign = Math.floor(version / 7) + 2;
|
|
49
|
+
const size = sizeOf(version);
|
|
50
|
+
const step = version === 32 ? 26 : Math.ceil((version * 4 + 4) / (numAlign * 2 - 2)) * 2;
|
|
51
|
+
const result = [6];
|
|
52
|
+
for (let pos = size - 7; result.length < numAlign; pos -= step)
|
|
53
|
+
result.splice(1, 0, pos);
|
|
54
|
+
return result;
|
|
55
|
+
}
|
|
56
|
+
// ---------- Reed–Solomon over GF(2^8), polynomial 0x11D ----------
|
|
57
|
+
function gfMul(x, y) {
|
|
58
|
+
let z = 0;
|
|
59
|
+
for (let i = 7; i >= 0; i--) {
|
|
60
|
+
z = (z << 1) ^ ((z >>> 7) * 0x11d);
|
|
61
|
+
z ^= ((y >>> i) & 1) * x;
|
|
62
|
+
}
|
|
63
|
+
return z & 0xff;
|
|
64
|
+
}
|
|
65
|
+
function rsDivisor(degree) {
|
|
66
|
+
const result = new Array(degree).fill(0);
|
|
67
|
+
result[degree - 1] = 1;
|
|
68
|
+
let root = 1;
|
|
69
|
+
for (let i = 0; i < degree; i++) {
|
|
70
|
+
for (let j = 0; j < result.length; j++) {
|
|
71
|
+
result[j] = gfMul(result[j], root);
|
|
72
|
+
if (j + 1 < result.length)
|
|
73
|
+
result[j] ^= result[j + 1];
|
|
67
74
|
}
|
|
68
|
-
|
|
75
|
+
root = gfMul(root, 0x02);
|
|
69
76
|
}
|
|
70
|
-
return
|
|
77
|
+
return result;
|
|
71
78
|
}
|
|
72
|
-
function
|
|
73
|
-
const
|
|
74
|
-
const res = new Array(ecLen).fill(0);
|
|
79
|
+
function rsRemainder(data, divisor) {
|
|
80
|
+
const result = new Array(divisor.length).fill(0);
|
|
75
81
|
for (const b of data) {
|
|
76
|
-
const factor = b ^
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
res[i] ^= gfMul(gen[i + 1] ?? 0, factor);
|
|
82
|
+
const factor = b ^ result.shift();
|
|
83
|
+
result.push(0);
|
|
84
|
+
for (let i = 0; i < divisor.length; i++)
|
|
85
|
+
result[i] ^= gfMul(divisor[i], factor);
|
|
81
86
|
}
|
|
82
|
-
return
|
|
87
|
+
return result;
|
|
83
88
|
}
|
|
84
|
-
|
|
89
|
+
// ---------- Data segment ----------
|
|
90
|
+
function buildCodewords(bytes, version) {
|
|
91
|
+
const capacityBits = numDataCodewords(version) * 8;
|
|
85
92
|
const bits = [];
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
bits.push((val >>> i) & 1);
|
|
90
|
-
},
|
|
91
|
-
toBytes() {
|
|
92
|
-
const out = [];
|
|
93
|
-
for (let i = 0; i < bits.length; i += 8) {
|
|
94
|
-
let b = 0;
|
|
95
|
-
for (let j = 0; j < 8; j++)
|
|
96
|
-
b = (b << 1) | (bits[i + j] ?? 0);
|
|
97
|
-
out.push(b);
|
|
98
|
-
}
|
|
99
|
-
return out;
|
|
100
|
-
},
|
|
101
|
-
get length() {
|
|
102
|
-
return bits.length;
|
|
103
|
-
}
|
|
93
|
+
const put = (val, len) => {
|
|
94
|
+
for (let i = len - 1; i >= 0; i--)
|
|
95
|
+
bits.push((val >>> i) & 1);
|
|
104
96
|
};
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
for (
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
97
|
+
put(0b0100, 4);
|
|
98
|
+
put(bytes.length, charCountBits(version));
|
|
99
|
+
for (const b of bytes)
|
|
100
|
+
put(b, 8);
|
|
101
|
+
put(0, Math.min(4, capacityBits - bits.length));
|
|
102
|
+
while (bits.length % 8 !== 0)
|
|
103
|
+
bits.push(0);
|
|
104
|
+
for (let pad = 0xec; bits.length < capacityBits; pad ^= 0xec ^ 0x11)
|
|
105
|
+
put(pad, 8);
|
|
106
|
+
const data = [];
|
|
107
|
+
for (let i = 0; i < bits.length; i += 8) {
|
|
108
|
+
let b = 0;
|
|
109
|
+
for (let j = 0; j < 8; j++)
|
|
110
|
+
b = (b << 1) | bits[i + j];
|
|
111
|
+
data.push(b);
|
|
113
112
|
}
|
|
114
|
-
return
|
|
113
|
+
return data;
|
|
115
114
|
}
|
|
116
|
-
function
|
|
117
|
-
|
|
115
|
+
function addEccAndInterleave(data, version) {
|
|
116
|
+
const numBlocks = NUM_BLOCKS_M[version - 1];
|
|
117
|
+
const eccLen = ECC_PER_BLOCK_M[version - 1];
|
|
118
|
+
const rawCodewords = Math.floor(numRawDataModules(version) / 8);
|
|
119
|
+
const numShortBlocks = numBlocks - (rawCodewords % numBlocks);
|
|
120
|
+
const shortBlockLen = Math.floor(rawCodewords / numBlocks);
|
|
121
|
+
const blocks = [];
|
|
122
|
+
const divisor = rsDivisor(eccLen);
|
|
123
|
+
let offset = 0;
|
|
124
|
+
for (let i = 0; i < numBlocks; i++) {
|
|
125
|
+
const len = shortBlockLen - eccLen + (i < numShortBlocks ? 0 : 1);
|
|
126
|
+
const dat = data.slice(offset, offset + len);
|
|
127
|
+
offset += len;
|
|
128
|
+
const ecc = rsRemainder(dat, divisor);
|
|
129
|
+
if (i < numShortBlocks)
|
|
130
|
+
dat.push(0);
|
|
131
|
+
blocks.push(dat.concat(ecc));
|
|
132
|
+
}
|
|
133
|
+
const result = [];
|
|
134
|
+
for (let i = 0; i < blocks[0].length; i++) {
|
|
135
|
+
blocks.forEach((block, j) => {
|
|
136
|
+
if (i !== shortBlockLen - eccLen || j >= numShortBlocks)
|
|
137
|
+
result.push(block[i]);
|
|
138
|
+
});
|
|
139
|
+
}
|
|
140
|
+
return result;
|
|
118
141
|
}
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
142
|
+
// ---------- Matrix drawing ----------
|
|
143
|
+
function drawFunctionPatterns(version, mod, fn) {
|
|
144
|
+
const size = mod.length;
|
|
145
|
+
const set = (x, y, dark) => {
|
|
146
|
+
mod[y][x] = dark;
|
|
147
|
+
fn[y][x] = true;
|
|
148
|
+
};
|
|
149
|
+
for (let i = 0; i < size; i++) {
|
|
150
|
+
set(6, i, i % 2 === 0);
|
|
151
|
+
set(i, 6, i % 2 === 0);
|
|
152
|
+
}
|
|
153
|
+
const finder = (cx, cy) => {
|
|
154
|
+
for (let dy = -4; dy <= 4; dy++) {
|
|
155
|
+
for (let dx = -4; dx <= 4; dx++) {
|
|
156
|
+
const dist = Math.max(Math.abs(dx), Math.abs(dy));
|
|
157
|
+
const x = cx + dx;
|
|
158
|
+
const y = cy + dy;
|
|
159
|
+
if (x >= 0 && x < size && y >= 0 && y < size)
|
|
160
|
+
set(x, y, dist !== 2 && dist !== 4);
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
};
|
|
164
|
+
finder(3, 3);
|
|
165
|
+
finder(size - 4, 3);
|
|
166
|
+
finder(3, size - 4);
|
|
167
|
+
const aligns = alignmentPositions(version);
|
|
168
|
+
const last = aligns.length - 1;
|
|
169
|
+
for (let i = 0; i < aligns.length; i++) {
|
|
170
|
+
for (let j = 0; j < aligns.length; j++) {
|
|
171
|
+
if ((i === 0 && j === 0) || (i === 0 && j === last) || (i === last && j === 0))
|
|
125
172
|
continue;
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
else
|
|
132
|
-
mod[rr][cc] = false;
|
|
173
|
+
for (let dy = -2; dy <= 2; dy++) {
|
|
174
|
+
for (let dx = -2; dx <= 2; dx++) {
|
|
175
|
+
set(aligns[i] + dx, aligns[j] + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
|
|
176
|
+
}
|
|
177
|
+
}
|
|
133
178
|
}
|
|
134
179
|
}
|
|
180
|
+
drawFormatBits(0, mod, fn);
|
|
181
|
+
drawVersion(version, mod, fn);
|
|
182
|
+
}
|
|
183
|
+
function drawFormatBits(mask, mod, fn) {
|
|
184
|
+
const size = mod.length;
|
|
185
|
+
const data = (ECL_M_FORMAT_BITS << 3) | mask;
|
|
186
|
+
let rem = data;
|
|
187
|
+
for (let i = 0; i < 10; i++)
|
|
188
|
+
rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
|
|
189
|
+
const bits = ((data << 10) | rem) ^ 0x5412;
|
|
190
|
+
const bit = (i) => ((bits >>> i) & 1) !== 0;
|
|
191
|
+
const set = (x, y, dark) => {
|
|
192
|
+
mod[y][x] = dark;
|
|
193
|
+
fn[y][x] = true;
|
|
194
|
+
};
|
|
195
|
+
for (let i = 0; i <= 5; i++)
|
|
196
|
+
set(8, i, bit(i));
|
|
197
|
+
set(8, 7, bit(6));
|
|
198
|
+
set(8, 8, bit(7));
|
|
199
|
+
set(7, 8, bit(8));
|
|
200
|
+
for (let i = 9; i < 15; i++)
|
|
201
|
+
set(14 - i, 8, bit(i));
|
|
202
|
+
for (let i = 0; i < 8; i++)
|
|
203
|
+
set(size - 1 - i, 8, bit(i));
|
|
204
|
+
for (let i = 8; i < 15; i++)
|
|
205
|
+
set(8, size - 15 + i, bit(i));
|
|
206
|
+
set(8, size - 8, true);
|
|
207
|
+
}
|
|
208
|
+
function drawVersion(version, mod, fn) {
|
|
209
|
+
if (version < 7)
|
|
210
|
+
return;
|
|
211
|
+
const size = mod.length;
|
|
212
|
+
let rem = version;
|
|
213
|
+
for (let i = 0; i < 12; i++)
|
|
214
|
+
rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
|
|
215
|
+
const bits = (version << 12) | rem;
|
|
216
|
+
for (let i = 0; i < 18; i++) {
|
|
217
|
+
const dark = ((bits >>> i) & 1) !== 0;
|
|
218
|
+
const a = size - 11 + (i % 3);
|
|
219
|
+
const b = Math.floor(i / 3);
|
|
220
|
+
mod[b][a] = dark;
|
|
221
|
+
fn[b][a] = true;
|
|
222
|
+
mod[a][b] = dark;
|
|
223
|
+
fn[a][b] = true;
|
|
224
|
+
}
|
|
135
225
|
}
|
|
136
|
-
function
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
226
|
+
function drawCodewords(codewords, mod, fn) {
|
|
227
|
+
const size = mod.length;
|
|
228
|
+
let i = 0;
|
|
229
|
+
const total = codewords.length * 8;
|
|
230
|
+
for (let right = size - 1; right >= 1; right -= 2) {
|
|
231
|
+
if (right === 6)
|
|
232
|
+
right = 5;
|
|
233
|
+
for (let vert = 0; vert < size; vert++) {
|
|
234
|
+
for (let j = 0; j < 2; j++) {
|
|
235
|
+
const x = right - j;
|
|
236
|
+
const upward = ((right + 1) & 2) === 0;
|
|
237
|
+
const y = upward ? size - 1 - vert : vert;
|
|
238
|
+
if (!fn[y][x] && i < total) {
|
|
239
|
+
mod[y][x] = ((codewords[i >>> 3] >>> (7 - (i & 7))) & 1) !== 0;
|
|
240
|
+
i++;
|
|
241
|
+
}
|
|
242
|
+
}
|
|
140
243
|
}
|
|
141
244
|
}
|
|
142
245
|
}
|
|
143
|
-
function
|
|
246
|
+
function maskBit(mask, x, y) {
|
|
144
247
|
switch (mask) {
|
|
145
248
|
case 0:
|
|
146
|
-
return (
|
|
249
|
+
return (x + y) % 2 === 0;
|
|
147
250
|
case 1:
|
|
148
|
-
return
|
|
251
|
+
return y % 2 === 0;
|
|
149
252
|
case 2:
|
|
150
|
-
return
|
|
253
|
+
return x % 3 === 0;
|
|
151
254
|
case 3:
|
|
152
|
-
return (
|
|
255
|
+
return (x + y) % 3 === 0;
|
|
153
256
|
case 4:
|
|
154
|
-
return (Math.floor(
|
|
257
|
+
return (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
|
|
155
258
|
case 5:
|
|
156
|
-
return ((
|
|
259
|
+
return ((x * y) % 2) + ((x * y) % 3) === 0;
|
|
157
260
|
case 6:
|
|
158
|
-
return (((
|
|
261
|
+
return (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
|
|
159
262
|
default:
|
|
160
|
-
return (((
|
|
263
|
+
return (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
|
|
161
264
|
}
|
|
162
265
|
}
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
const ecLen = ECC_CODEWORDS_PER_BLOCK[version];
|
|
170
|
-
const buf = bitBuffer();
|
|
171
|
-
buf.put(0b0100, 4); // byte mode
|
|
172
|
-
buf.put(bytes.length, version <= 9 ? 8 : 16);
|
|
173
|
-
for (const b of bytes)
|
|
174
|
-
buf.put(b, 8);
|
|
175
|
-
buf.put(0, Math.min(4, dataCapacity * 8 - buf.length));
|
|
176
|
-
while (buf.length % 8 !== 0)
|
|
177
|
-
buf.put(0, 1);
|
|
178
|
-
const data = buf.toBytes();
|
|
179
|
-
const pad = [0xec, 0x11];
|
|
180
|
-
let pi = 0;
|
|
181
|
-
while (data.length < dataCapacity)
|
|
182
|
-
data.push(pad[pi++ % 2]);
|
|
183
|
-
const ec = rsEncode(data.slice(0, dataCapacity), ecLen);
|
|
184
|
-
const codewords = [...data.slice(0, dataCapacity), ...ec];
|
|
185
|
-
const mod = Array.from({ length: size }, () => Array(size).fill(null));
|
|
186
|
-
placeFinder(mod, 0, 0);
|
|
187
|
-
placeFinder(mod, 0, size - 7);
|
|
188
|
-
placeFinder(mod, size - 7, 0);
|
|
189
|
-
for (let i = 8; i < size - 8; i++) {
|
|
190
|
-
if (mod[6][i] === null)
|
|
191
|
-
mod[6][i] = i % 2 === 0;
|
|
192
|
-
if (mod[i][6] === null)
|
|
193
|
-
mod[i][6] = i % 2 === 0;
|
|
194
|
-
}
|
|
195
|
-
const aligns = ALIGNMENT[version];
|
|
196
|
-
for (const r of aligns) {
|
|
197
|
-
for (const c of aligns) {
|
|
198
|
-
if (mod[r][c] !== null)
|
|
199
|
-
continue;
|
|
200
|
-
placeAlignment(mod, r, c);
|
|
266
|
+
function applyMask(mask, mod, fn) {
|
|
267
|
+
const size = mod.length;
|
|
268
|
+
for (let y = 0; y < size; y++) {
|
|
269
|
+
for (let x = 0; x < size; x++) {
|
|
270
|
+
if (!fn[y][x] && maskBit(mask, x, y))
|
|
271
|
+
mod[y][x] = !mod[y][x];
|
|
201
272
|
}
|
|
202
273
|
}
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
mod[
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
274
|
+
}
|
|
275
|
+
function penaltyScore(mod) {
|
|
276
|
+
const size = mod.length;
|
|
277
|
+
let result = 0;
|
|
278
|
+
let dark = 0;
|
|
279
|
+
for (let y = 0; y < size; y++) {
|
|
280
|
+
let runColor = false;
|
|
281
|
+
let runX = 0;
|
|
282
|
+
for (let x = 0; x < size; x++) {
|
|
283
|
+
if (mod[y][x] === runColor) {
|
|
284
|
+
runX++;
|
|
285
|
+
if (runX === 5)
|
|
286
|
+
result += 3;
|
|
287
|
+
else if (runX > 5)
|
|
288
|
+
result++;
|
|
289
|
+
}
|
|
290
|
+
else {
|
|
291
|
+
runColor = mod[y][x];
|
|
292
|
+
runX = 1;
|
|
293
|
+
}
|
|
294
|
+
if (mod[y][x])
|
|
295
|
+
dark++;
|
|
296
|
+
}
|
|
221
297
|
}
|
|
222
|
-
let
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
298
|
+
for (let x = 0; x < size; x++) {
|
|
299
|
+
let runColor = false;
|
|
300
|
+
let runY = 0;
|
|
301
|
+
for (let y = 0; y < size; y++) {
|
|
302
|
+
if (mod[y][x] === runColor) {
|
|
303
|
+
runY++;
|
|
304
|
+
if (runY === 5)
|
|
305
|
+
result += 3;
|
|
306
|
+
else if (runY > 5)
|
|
307
|
+
result++;
|
|
308
|
+
}
|
|
309
|
+
else {
|
|
310
|
+
runColor = mod[y][x];
|
|
311
|
+
runY = 1;
|
|
234
312
|
}
|
|
235
313
|
}
|
|
236
|
-
direction *= -1;
|
|
237
314
|
}
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
out[r][c] = maskFn(mask, r, c) ? !dark : dark;
|
|
315
|
+
for (let y = 0; y < size - 1; y++) {
|
|
316
|
+
for (let x = 0; x < size - 1; x++) {
|
|
317
|
+
const c = mod[y][x];
|
|
318
|
+
if (c === mod[y][x + 1] && c === mod[y + 1][x] && c === mod[y + 1][x + 1])
|
|
319
|
+
result += 3;
|
|
244
320
|
}
|
|
245
321
|
}
|
|
246
|
-
|
|
247
|
-
const
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
322
|
+
const total = size * size;
|
|
323
|
+
const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
|
|
324
|
+
result += k * 10;
|
|
325
|
+
return result;
|
|
326
|
+
}
|
|
327
|
+
/** Returns a square boolean matrix (true = dark module). */
|
|
328
|
+
export function encodeQR(text) {
|
|
329
|
+
const bytes = Array.from(new TextEncoder().encode(text));
|
|
330
|
+
const version = chooseVersion(bytes.length);
|
|
331
|
+
const size = sizeOf(version);
|
|
332
|
+
const codewords = addEccAndInterleave(buildCodewords(bytes, version), version);
|
|
333
|
+
const mod = Array.from({ length: size }, () => Array(size).fill(false));
|
|
334
|
+
const fn = Array.from({ length: size }, () => Array(size).fill(false));
|
|
335
|
+
drawFunctionPatterns(version, mod, fn);
|
|
336
|
+
drawCodewords(codewords, mod, fn);
|
|
337
|
+
let bestMask = 0;
|
|
338
|
+
let bestScore = Number.POSITIVE_INFINITY;
|
|
339
|
+
for (let mask = 0; mask < 8; mask++) {
|
|
340
|
+
applyMask(mask, mod, fn);
|
|
341
|
+
drawFormatBits(mask, mod, fn);
|
|
342
|
+
const score = penaltyScore(mod);
|
|
343
|
+
if (score < bestScore) {
|
|
344
|
+
bestScore = score;
|
|
345
|
+
bestMask = mask;
|
|
346
|
+
}
|
|
347
|
+
applyMask(mask, mod, fn);
|
|
264
348
|
}
|
|
265
|
-
|
|
349
|
+
applyMask(bestMask, mod, fn);
|
|
350
|
+
drawFormatBits(bestMask, mod, fn);
|
|
351
|
+
return mod;
|
|
266
352
|
}
|
|
267
353
|
export function qrToSvgPath(matrix, cell = 1) {
|
|
268
354
|
const parts = [];
|