@rozenite/storage-plugin 1.8.1 → 1.10.0

package/src/ui/__tests__/binary.test.ts

@@ -0,0 +1,251 @@
+import { describe, expect, it } from 'vitest';
+import {
+  base64ToBytes,
+  bytesToAsciiPreview,
+  bytesToBase64,
+  bytesToGroupedHex,
+  bytesToHexdump,
+  compactBufferPreview,
+  hexInputToBytes,
+} from '../binary';
+
+// 0x89 'P' 'N' 'G' \r \n 0x1A \n - the canonical PNG signature.
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+
+describe('bytesToGroupedHex', () => {
+  it('returns empty string for empty bytes', () => {
+    expect(bytesToGroupedHex([])).toBe('');
+  });
+
+  it('groups under 8 bytes without a double-space separator', () => {
+    expect(bytesToGroupedHex([0x89, 0x50])).toBe('89 50');
+  });
+
+  it('inserts a double-space gap between bytes 8 and 9', () => {
+    expect(
+      bytesToGroupedHex([
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
+        0x49, 0x48, 0x44, 0x52,
+      ]),
+    ).toBe('89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52');
+  });
+
+  it('wraps after 16 bytes with a newline', () => {
+    const bytes = new Array(20).fill(0xff);
+    const out = bytesToGroupedHex(bytes);
+    const lines = out.split('\n');
+    expect(lines).toHaveLength(2);
+    expect(lines[0]).toBe('FF FF FF FF FF FF FF FF  FF FF FF FF FF FF FF FF');
+    expect(lines[1]).toBe('FF FF FF FF');
+  });
+});
+
+describe('bytesToHexdump', () => {
+  it('renders offset, grouped hex, and ASCII column', () => {
+    const bytes = [
+      ...PNG_SIGNATURE,
+      0x00,
+      0x00,
+      0x00,
+      0x0d,
+      0x49,
+      0x48,
+      0x44,
+      0x52,
+    ];
+    expect(bytesToHexdump(bytes)).toBe(
+      '00000000  89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52  |.PNG........IHDR|',
+    );
+  });
+
+  it('uses lowercase 8-digit offsets that increment by 16', () => {
+    const bytes = new Array(20).fill(0x41);
+    const lines = bytesToHexdump(bytes).split('\n');
+    expect(lines[0].startsWith('00000000  ')).toBe(true);
+    expect(lines[1].startsWith('00000010  ')).toBe(true);
+  });
+
+  it('pads the hex column on a partial trailing line so ASCII aligns', () => {
+    const bytes = [0x41, 0x42, 0x43];
+    const line = bytesToHexdump(bytes);
+    // Hex section width must be exactly 48 chars before the "  |..." block.
+    expect(line).toBe(
+      '00000000  41 42 43                                          |ABC|',
+    );
+  });
+
+  it('renders non-printable bytes as dots in the ASCII column', () => {
+    const bytes = [0x00, 0x09, 0x1f, 0x20, 0x7e, 0x7f, 0xff];
+    expect(bytesToHexdump(bytes)).toContain('|... ~..|');
+  });
+});
+
+describe('bytesToAsciiPreview', () => {
+  it('maps printable bytes to characters', () => {
+    expect(bytesToAsciiPreview([0x48, 0x69])).toBe('Hi');
+  });
+
+  it('treats bytes outside 0x20..0x7E as "."', () => {
+    expect(bytesToAsciiPreview([0x1f, 0x20, 0x7e, 0x7f])).toBe('. ~.');
+  });
+
+  it('treats tab and newline as non-printable', () => {
+    expect(bytesToAsciiPreview([0x09, 0x0a, 0x0d])).toBe('...');
+  });
+});
+
+describe('bytesToBase64 / base64ToBytes round-trip', () => {
+  it('encodes simple ASCII to base64 and back', () => {
+    const bytes = [0x48, 0x65, 0x6c, 0x6c, 0x6f]; // "Hello"
+    const encoded = bytesToBase64(bytes);
+    expect(encoded).toBe('SGVsbG8=');
+    const decoded = base64ToBytes(encoded);
+    expect(decoded).toEqual({ ok: true, value: bytes });
+  });
+
+  it('round-trips arbitrary bytes including high values', () => {
+    const bytes = [0x00, 0xff, 0x89, 0x50, 0x4e, 0x47];
+    const decoded = base64ToBytes(bytesToBase64(bytes));
+    expect(decoded).toEqual({ ok: true, value: bytes });
+  });
+
+  it('accepts base64 with surrounding and internal whitespace', () => {
+    expect(base64ToBytes('  SGVs\nbG8=  ')).toEqual({
+      ok: true,
+      value: [0x48, 0x65, 0x6c, 0x6c, 0x6f],
+    });
+  });
+
+  it('rejects empty input with the canonical message', () => {
+    expect(base64ToBytes('')).toEqual({
+      ok: false,
+      error: 'Enter at least one byte.',
+    });
+    expect(base64ToBytes('   ')).toEqual({
+      ok: false,
+      error: 'Enter at least one byte.',
+    });
+  });
+
+  it('rejects malformed base64', () => {
+    expect(base64ToBytes('not*valid*base64')).toEqual({
+      ok: false,
+      error: 'Base64 input is invalid.',
+    });
+  });
+});
+
+describe('compactBufferPreview', () => {
+  it('renders just the size for an empty buffer', () => {
+    expect(compactBufferPreview([])).toBe('0 B');
+  });
+
+  it('omits the ellipsis when the buffer fits within maxBytes', () => {
+    expect(compactBufferPreview([0x89, 0x50, 0x4e, 0x47])).toBe(
+      '89 50 4E 47 4 B',
+    );
+  });
+
+  it('includes an ellipsis when truncated', () => {
+    expect(compactBufferPreview(new Array(128).fill(0xab))).toBe(
+      'AB AB AB AB AB AB AB AB … 128 B',
+    );
+  });
+
+  it('respects a custom maxBytes', () => {
+    expect(compactBufferPreview([0x01, 0x02, 0x03], { maxBytes: 2 })).toBe(
+      '01 02 … 3 B',
+    );
+  });
+});
+
+describe('hexInputToBytes', () => {
+  it('parses continuous hex', () => {
+    expect(hexInputToBytes('deadbeef')).toEqual({
+      ok: true,
+      value: [0xde, 0xad, 0xbe, 0xef],
+    });
+  });
+
+  it('parses grouped hex', () => {
+    expect(hexInputToBytes('DE AD BE EF')).toEqual({
+      ok: true,
+      value: [0xde, 0xad, 0xbe, 0xef],
+    });
+  });
+
+  it('parses multiline grouped hex', () => {
+    expect(
+      hexInputToBytes(
+        '89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52\n00 00 00 20 00 00 00 20',
+      ),
+    ).toEqual({
+      ok: true,
+      value: [
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
+        0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
+      ],
+    });
+  });
+
+  it('parses pasted hexdump rows, stripping offsets and ASCII column', () => {
+    const pasted = [
+      '00000000  89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52  |.PNG........IHDR|',
+      '00000010  00 00 00 20 00 00 00 20  08 06 00 00 00 73 7A 7A  |... ... .....szz|',
+    ].join('\n');
+    expect(hexInputToBytes(pasted)).toEqual({
+      ok: true,
+      value: [
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
+        0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
+        0x08, 0x06, 0x00, 0x00, 0x00, 0x73, 0x7a, 0x7a,
+      ],
+    });
+  });
+
+  it('accepts colon-separated hexdump offsets', () => {
+    expect(hexInputToBytes('00000000: 89 50 4E 47')).toEqual({
+      ok: true,
+      value: [0x89, 0x50, 0x4e, 0x47],
+    });
+  });
+
+  it('strips "0x" prefixes', () => {
+    expect(hexInputToBytes('0xDE 0xAD 0xBE 0xEF')).toEqual({
+      ok: true,
+      value: [0xde, 0xad, 0xbe, 0xef],
+    });
+  });
+
+  it('tolerates mixed case', () => {
+    expect(hexInputToBytes('De Ad bE eF')).toEqual({
+      ok: true,
+      value: [0xde, 0xad, 0xbe, 0xef],
+    });
+  });
+
+  it('rejects empty input with the canonical message', () => {
+    expect(hexInputToBytes('')).toEqual({
+      ok: false,
+      error: 'Enter at least one byte.',
+    });
+    expect(hexInputToBytes('   \n   ')).toEqual({
+      ok: false,
+      error: 'Enter at least one byte.',
+    });
+  });
+
+  it('rejects non-hex characters', () => {
+    expect(hexInputToBytes('DE AD GG')).toEqual({
+      ok: false,
+      error: 'Hex input contains invalid characters.',
+    });
+  });
+
+  it('rejects odd hex digit count', () => {
+    expect(hexInputToBytes('DEAD B')).toEqual({
+      ok: false,
+      error: 'Hex input must contain complete bytes.',
+    });
+  });
+});

package/src/ui/__tests__/type-conversion.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest';
+import { convertValue, defaultValueForType } from '../type-conversion';
+
+describe('convertValue', () => {
+  it('returns the same value when from === to', () => {
+    expect(convertValue('string', 'string', 'hello')).toBe('hello');
+    expect(convertValue('number', 'number', 42)).toBe(42);
+    expect(convertValue('boolean', 'boolean', true)).toBe(true);
+    expect(convertValue('buffer', 'buffer', [1, 2, 3])).toEqual([1, 2, 3]);
+  });
+
+  describe('from string', () => {
+    it('parses a numeric string to a number, falls back to 0 on NaN', () => {
+      expect(convertValue('string', 'number', '42')).toBe(42);
+      expect(convertValue('string', 'number', '-3.14')).toBe(-3.14);
+      expect(convertValue('string', 'number', 'abc')).toBe(0);
+      expect(convertValue('string', 'number', '')).toBe(0);
+    });
+
+    it('parses "true" / anything-else to a boolean', () => {
+      expect(convertValue('string', 'boolean', 'true')).toBe(true);
+      expect(convertValue('string', 'boolean', 'false')).toBe(false);
+      expect(convertValue('string', 'boolean', 'anything')).toBe(false);
+      expect(convertValue('string', 'boolean', '')).toBe(false);
+    });
+
+    it('UTF-8 encodes a string to a byte array', () => {
+      expect(convertValue('string', 'buffer', 'hello')).toEqual([
+        0x68, 0x65, 0x6c, 0x6c, 0x6f,
+      ]);
+      // 'é' is two bytes in UTF-8: 0xC3 0xA9.
+      expect(convertValue('string', 'buffer', 'café')).toEqual([
+        0x63, 0x61, 0x66, 0xc3, 0xa9,
+      ]);
+      expect(convertValue('string', 'buffer', '')).toEqual([]);
+    });
+  });
+
+  describe('from number', () => {
+    it('stringifies a number when converting to string', () => {
+      expect(convertValue('number', 'string', 42)).toBe('42');
+      expect(convertValue('number', 'string', -3.14)).toBe('-3.14');
+      expect(convertValue('number', 'string', 0)).toBe('0');
+    });
+
+    it('non-zero is truthy, zero is falsy for boolean conversion', () => {
+      expect(convertValue('number', 'boolean', 1)).toBe(true);
+      expect(convertValue('number', 'boolean', -1)).toBe(true);
+      expect(convertValue('number', 'boolean', 0)).toBe(false);
+    });
+
+    it('UTF-8 encodes the stringified number to buffer', () => {
+      expect(convertValue('number', 'buffer', 42)).toEqual([0x34, 0x32]);
+    });
+  });
+
+  describe('from boolean', () => {
+    it('stringifies to "true" / "false"', () => {
+      expect(convertValue('boolean', 'string', true)).toBe('true');
+      expect(convertValue('boolean', 'string', false)).toBe('false');
+    });
+
+    it('true → 1, false → 0 for number conversion', () => {
+      expect(convertValue('boolean', 'number', true)).toBe(1);
+      expect(convertValue('boolean', 'number', false)).toBe(0);
+    });
+
+    it('encodes the literal "true" / "false" bytes for buffer conversion', () => {
+      expect(convertValue('boolean', 'buffer', true)).toEqual([
+        0x74, 0x72, 0x75, 0x65,
+      ]);
+      expect(convertValue('boolean', 'buffer', false)).toEqual([
+        0x66, 0x61, 0x6c, 0x73, 0x65,
+      ]);
+    });
+  });
+
+  describe('from buffer', () => {
+    it('UTF-8 decodes bytes back to a string (the headline round-trip)', () => {
+      expect(
+        convertValue('buffer', 'string', [0x68, 0x65, 0x6c, 0x6c, 0x6f]),
+      ).toBe('hello');
+    });
+
+    it('returns an empty string when bytes are not valid UTF-8', () => {
+      expect(convertValue('buffer', 'string', [0xff, 0xfe, 0xfd])).toBe('');
+    });
+
+    it('decodes then parses to number, falls back to 0 on failure', () => {
+      expect(convertValue('buffer', 'number', [0x34, 0x32])).toBe(42); // "42"
+      expect(
+        convertValue('buffer', 'number', [0x68, 0x65, 0x6c, 0x6c, 0x6f]),
+      ).toBe(0); // "hello" → NaN → 0
+      expect(convertValue('buffer', 'number', [0xff])).toBe(0); // invalid UTF-8 → 0
+    });
+
+    it('decodes then matches "true" for boolean conversion', () => {
+      expect(convertValue('buffer', 'boolean', [0x74, 0x72, 0x75, 0x65])).toBe(
+        true,
+      );
+      expect(
+        convertValue('buffer', 'boolean', [0x66, 0x61, 0x6c, 0x73, 0x65]),
+      ).toBe(false);
+      expect(convertValue('buffer', 'boolean', [0xff])).toBe(false);
+    });
+  });
+
+  it('round-trips string ↔ buffer faithfully', () => {
+    const original = 'Hello, world! — 你好';
+    const bytes = convertValue('string', 'buffer', original) as number[];
+    const back = convertValue('buffer', 'string', bytes);
+    expect(back).toBe(original);
+  });
+});
+
+describe('defaultValueForType', () => {
+  it('returns sensible zero values', () => {
+    expect(defaultValueForType('string')).toBe('');
+    expect(defaultValueForType('number')).toBe(0);
+    expect(defaultValueForType('boolean')).toBe(false);
+    expect(defaultValueForType('buffer')).toEqual([]);
+  });
+});