feat(monorepo): migrate vue packages and apply oxlint refactors
This commit is contained in:
@@ -0,0 +1,100 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import { computeDivisor, computeRemainder, multiply } from '.';
|
||||
|
||||
describe('multiply', () => {
|
||||
it('multiplies zero by anything to get zero', () => {
|
||||
expect(multiply(0, 0)).toBe(0);
|
||||
expect(multiply(0, 1)).toBe(0);
|
||||
expect(multiply(0, 255)).toBe(0);
|
||||
expect(multiply(1, 0)).toBe(0);
|
||||
});
|
||||
|
||||
it('multiplies by one (identity)', () => {
|
||||
expect(multiply(1, 1)).toBe(1);
|
||||
expect(multiply(1, 42)).toBe(42);
|
||||
expect(multiply(42, 1)).toBe(42);
|
||||
expect(multiply(1, 255)).toBe(255);
|
||||
});
|
||||
|
||||
it('is commutative', () => {
|
||||
expect(multiply(5, 7)).toBe(multiply(7, 5));
|
||||
expect(multiply(0x53, 0xCA)).toBe(multiply(0xCA, 0x53));
|
||||
expect(multiply(100, 200)).toBe(multiply(200, 100));
|
||||
});
|
||||
|
||||
it('produces known GF(2^8) products', () => {
|
||||
expect(multiply(2, 2)).toBe(4);
|
||||
expect(multiply(2, 0x80)).toBe(0x1D);
|
||||
});
|
||||
|
||||
it('throws on out of range inputs', () => {
|
||||
expect(() => multiply(256, 0)).toThrow(RangeError);
|
||||
expect(() => multiply(0, 256)).toThrow(RangeError);
|
||||
expect(() => multiply(1000, 1000)).toThrow(RangeError);
|
||||
});
|
||||
});
|
||||
|
||||
describe('computeDivisor', () => {
|
||||
it('computes a degree-1 divisor', () => {
|
||||
expect(computeDivisor(1)).toEqual(Uint8Array.from([1]));
|
||||
});
|
||||
|
||||
it('computes a degree-2 divisor', () => {
|
||||
const result = computeDivisor(2);
|
||||
expect(result).toHaveLength(2);
|
||||
expect(result).toEqual(Uint8Array.from([3, 2]));
|
||||
});
|
||||
|
||||
it('has correct length for arbitrary degrees', () => {
|
||||
expect(computeDivisor(7)).toHaveLength(7);
|
||||
expect(computeDivisor(10)).toHaveLength(10);
|
||||
expect(computeDivisor(30)).toHaveLength(30);
|
||||
});
|
||||
|
||||
it('returns Uint8Array', () => {
|
||||
expect(computeDivisor(5)).toBeInstanceOf(Uint8Array);
|
||||
});
|
||||
|
||||
it('throws on degree out of range', () => {
|
||||
expect(() => computeDivisor(0)).toThrow(RangeError);
|
||||
expect(() => computeDivisor(256)).toThrow(RangeError);
|
||||
expect(() => computeDivisor(-1)).toThrow(RangeError);
|
||||
});
|
||||
});
|
||||
|
||||
describe('computeRemainder', () => {
|
||||
it('returns zero remainder for empty data', () => {
|
||||
const divisor = computeDivisor(4);
|
||||
const result = computeRemainder([], divisor);
|
||||
expect(result).toEqual(new Uint8Array(4));
|
||||
});
|
||||
|
||||
it('produces non-zero remainder for non-empty data', () => {
|
||||
const divisor = computeDivisor(7);
|
||||
const data = [0x40, 0xD2, 0x75, 0x47, 0x76, 0x17, 0x32, 0x06, 0x27, 0x26, 0x96, 0xC6, 0xC6, 0x96, 0x70, 0xEC];
|
||||
const result = computeRemainder(data, divisor);
|
||||
expect(result).toHaveLength(7);
|
||||
expect(result).toBeInstanceOf(Uint8Array);
|
||||
for (const b of result) {
|
||||
expect(b).toBeGreaterThanOrEqual(0);
|
||||
expect(b).toBeLessThanOrEqual(255);
|
||||
}
|
||||
});
|
||||
|
||||
it('accepts Uint8Array as data input', () => {
|
||||
const divisor = computeDivisor(7);
|
||||
const data = Uint8Array.from([0x40, 0xD2, 0x75, 0x47]);
|
||||
const result = computeRemainder(data, divisor);
|
||||
expect(result).toHaveLength(7);
|
||||
expect(result).toBeInstanceOf(Uint8Array);
|
||||
});
|
||||
|
||||
it('remainder length matches divisor length', () => {
|
||||
for (const degree of [1, 5, 10, 20]) {
|
||||
const divisor = computeDivisor(degree);
|
||||
const data = [1, 2, 3, 4, 5];
|
||||
const result = computeRemainder(data, divisor);
|
||||
expect(result).toHaveLength(degree);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,92 @@
|
||||
/*
|
||||
* Reed-Solomon error correction over GF(2^8/0x11D)
|
||||
*
|
||||
* Based on Project Nayuki's QR Code generator library (MIT License)
|
||||
* https://www.nayuki.io/page/qr-code-generator-library
|
||||
*/
|
||||
|
||||
/* -- GF(2^8) exp/log lookup tables (generator α=0x02, primitive polynomial 0x11D) -- */
|
||||
|
||||
const GF_EXP = new Uint8Array(256);
|
||||
const GF_LOG = new Uint8Array(256);
|
||||
|
||||
{
|
||||
let x = 1;
|
||||
for (let i = 0; i < 255; i++) {
|
||||
GF_EXP[i] = x;
|
||||
GF_LOG[x] = i;
|
||||
x = (x << 1) ^ ((x >>> 7) * 0x11D);
|
||||
}
|
||||
GF_EXP[255] = GF_EXP[0]!;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the product of the two given field elements modulo GF(2^8/0x11D).
|
||||
* The arguments and result are unsigned 8-bit integers.
|
||||
*/
|
||||
export function multiply(x: number, y: number): number {
|
||||
if (x >>> 8 !== 0 || y >>> 8 !== 0)
|
||||
throw new RangeError('Byte out of range');
|
||||
|
||||
if (x === 0 || y === 0)
|
||||
return 0;
|
||||
|
||||
return GF_EXP[(GF_LOG[x]! + GF_LOG[y]!) % 255]!;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a Reed-Solomon ECC generator polynomial for the given degree.
|
||||
*
|
||||
* Polynomial coefficients are stored from highest to lowest power, excluding the leading term which is always 1.
|
||||
* For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array [255, 8, 93].
|
||||
*/
|
||||
export function computeDivisor(degree: number): Uint8Array {
|
||||
if (degree < 1 || degree > 255)
|
||||
throw new RangeError('Degree out of range');
|
||||
|
||||
const result = new Uint8Array(degree);
|
||||
result[degree - 1] = 1;
|
||||
|
||||
// Compute the product polynomial (x - r^0) * (x - r^1) * ... * (x - r^{degree-1}),
|
||||
// dropping the leading term which is always 1x^degree.
|
||||
// r = 0x02, a generator element of GF(2^8/0x11D).
|
||||
let root = 0; // GF_LOG[1] = 0, i.e. α^0 = 1
|
||||
for (let i = 0; i < degree; i++) {
|
||||
// Multiply the current product by (x - r^i)
|
||||
for (let j = 0; j < degree; j++) {
|
||||
// result[j] = multiply(result[j], α^root) — inlined for performance
|
||||
if (result[j] !== 0)
|
||||
result[j] = GF_EXP[(GF_LOG[result[j]!]! + root) % 255]!;
|
||||
if (j + 1 < degree)
|
||||
result[j]! ^= result[j + 1]!;
|
||||
}
|
||||
root = (root + 1) % 255; // root tracks log(α^i) = i mod 255
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.
|
||||
*/
|
||||
export function computeRemainder(data: ArrayLike<number>, divisor: Uint8Array): Uint8Array {
|
||||
const len = divisor.length;
|
||||
const result = new Uint8Array(len);
|
||||
|
||||
for (let d = 0, dLen = data.length; d < dLen; d++) {
|
||||
const factor = data[d]! ^ result[0]!;
|
||||
// Shift left by 1 position (native memcpy)
|
||||
result.copyWithin(0, 1);
|
||||
result[len - 1] = 0;
|
||||
// XOR with divisor scaled by factor — inlined GF multiply for performance
|
||||
if (factor !== 0) {
|
||||
const logFactor = GF_LOG[factor]!;
|
||||
for (let i = 0; i < len; i++) {
|
||||
if (divisor[i] !== 0)
|
||||
result[i]! ^= GF_EXP[(GF_LOG[divisor[i]!]! + logFactor) % 255]!;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
Reference in New Issue
Block a user