@rozenite/storage-plugin 1.9.0 → 1.11.0

package/src/react-native/adapters/mmkv.ts

@@ -1,8 +1,11 @@
 import type { MMKV as MMKVV3 } from 'react-native-mmkv-v3';
 import type { MMKV as MMKVV4 } from 'react-native-mmkv-v4';
-import type { StorageAdapter, StorageEntry, StorageNode } from '../../shared/types';
+import type {
+  StorageAdapter,
+  StorageEntry,
+  StorageNode,
+} from '../../shared/types';
 import { DEFAULT_SUPPORTED_TYPES } from '../../shared/types';
-import { looksLikeGarbled } from '../is-garbled';
 
 type MMKV = MMKVV3 | MMKVV4;
 
@@ -36,12 +39,12 @@ const normalizeStorages = (storages: MMKV[] | Record<string, MMKV>) => {
 
     if (isAnyStorageV4) {
       throw new Error(
-        '[Rozenite] Storage Plugin: MMKV arrays are not supported for v4 storages. Pass a record of storage IDs and MMKV instances.'
+        '[Rozenite] Storage Plugin: MMKV arrays are not supported for v4 storages. Pass a record of storage IDs and MMKV instances.',
       );
     }
 
     return Object.fromEntries(
-      (storages as MMKVV3[]).map((storage) => [storage['id'], storage])
+      (storages as MMKVV3[]).map((storage) => [storage['id'], storage]),
     );
   }
 
@@ -71,54 +74,60 @@ const getMMKVAdapter = (mmkv: MMKV): MMKVAdapter => {
     getBuffer: (key) => mmkv.getBuffer(key) as ArrayBuffer | undefined,
     delete: (key) => mmkv.delete(key),
     getAllKeys: () => mmkv.getAllKeys(),
-    addOnValueChangedListener: (callback) => mmkv.addOnValueChangedListener(callback),
+    addOnValueChangedListener: (callback) =>
+      mmkv.addOnValueChangedListener(callback),
   };
 };
 
-const getEntry = (adapter: MMKVAdapter, key: string): StorageEntry | undefined => {
+// MMKV's typed getters can disagree on the same key — on some platforms
+// `getString` lenient-decodes invalid-UTF-8 buffer bytes to `""`, and
+// `getNumber` reinterprets 8-byte buffers as IEEE 754 doubles without
+// honoring the original `setBuffer` write. `getBuffer` is more reliably
+// strict (only returns for keys actually written via `setBuffer`), so
+// we consult it ahead of the numeric getters to break ties in favour of
+// the bytes that are actually on disk.
+//
+//   1. Non-empty string — the common case. Buffer bytes that happen to
+//      be valid UTF-8 surface here too (documented trade-off); users
+//      disambiguate at edit time via the Hex editor.
+//   2. Non-empty buffer — catches `setBuffer` payloads regardless of
+//      byte count and regardless of whether the other typed getters
+//      also return spurious values.
+//   3. Number, then boolean — for keys actually written via `setNumber`
+//      / `setBoolean`. `getBuffer` will have returned `undefined` for
+//      those keys, so the chain falls through.
+//   4. Empty string — intentional `setString(key, "")` lands here once
+//      we've ruled out a non-empty buffer payload at the same key.
+const getEntry = (
+  adapter: MMKVAdapter,
+  key: string,
+): StorageEntry | undefined => {
   const stringValue = adapter.getString(key);
-
   if (stringValue !== undefined && stringValue.length > 0) {
-    if (looksLikeGarbled(stringValue)) {
-      return {
-        key,
-        type: 'buffer',
-        value: Array.from(new TextEncoder().encode(stringValue)),
-      };
-    }
+    return { key, type: 'string', value: stringValue };
+  }
 
+  const bufferValue = adapter.getBuffer(key);
+  if (bufferValue !== undefined && bufferValue.byteLength > 0) {
     return {
       key,
-      type: 'string',
-      value: stringValue,
+      type: 'buffer',
+      value: Array.from(new Uint8Array(bufferValue)),
     };
   }
 
   const numberValue = adapter.getNumber(key);
   if (numberValue !== undefined) {
-    return {
-      key,
-      type: 'number',
-      value: numberValue,
-    };
+    return { key, type: 'number', value: numberValue };
   }
 
   const booleanValue = adapter.getBoolean(key);
   if (booleanValue !== undefined) {
-    return {
-      key,
-      type: 'boolean',
-      value: booleanValue,
-    };
+    return { key, type: 'boolean', value: booleanValue };
   }
 
-  const bufferValue = adapter.getBuffer(key);
-  if (bufferValue !== undefined) {
-    return {
-      key,
-      type: 'buffer',
-      value: Array.from(new Uint8Array(bufferValue)),
-    };
+  if (stringValue !== undefined) {
+    return { key, type: 'string', value: stringValue };
   }
 
   return undefined;
@@ -127,15 +136,14 @@ const getEntry = (adapter: MMKVAdapter, key: string): StorageEntry | undefined =
 const setEntry = (adapter: MMKVAdapter, entry: StorageEntry) => {
   if (entry.type === 'buffer') {
     adapter.set(entry.key, new Uint8Array(entry.value).buffer);
-    return;
+  } else {
+    adapter.set(entry.key, entry.value);
   }
-
-  adapter.set(entry.key, entry.value);
 };
 
 const getStorageBlacklist = (
   config: MMKVBlacklistConfig | undefined,
-  storageId: string
+  storageId: string,
 ) => {
   if (!config) {
     return undefined;
@@ -150,7 +158,7 @@ const getStorageBlacklist = (
 
 const createStorageBlacklistMatcher = (
   config: MMKVBlacklistConfig | undefined,
-  storageId: string
+  storageId: string,
 ) => {
   if (!(config instanceof RegExp)) {
     return undefined;
@@ -168,7 +176,10 @@ export const createMMKVStorageAdapter = ({
   storages,
   blacklist,
 }: CreateMMKVStorageAdapterOptions): StorageAdapter => {
-  const normalizedStorages = normalizeStorages(storages) as Record<string, MMKV>;
+  const normalizedStorages = normalizeStorages(storages) as Record<
+    string,
+    MMKV
+  >;
 
   const storageNodes: StorageNode[] = Object.entries(normalizedStorages).map(
     ([storageId, storage]) => {
@@ -191,7 +202,7 @@ export const createMMKVStorageAdapter = ({
           subscribe: (callback) => mmkv.addOnValueChangedListener(callback),
         },
       };
-    }
+    },
   );
 
   return {

package/src/ui/__tests__/binary-value-editor-state.test.ts

@@ -0,0 +1,199 @@
+import { describe, expect, it } from 'vitest';
+import {
+  initialState,
+  reduce,
+  validate,
+  type EditorState,
+} from '../binary-value-editor-state';
+
+const hexState = (bytes?: number[]): EditorState =>
+  initialState({ initialBytes: bytes, mode: 'hex' });
+
+describe('initialState', () => {
+  it('defaults to hex mode and empty text when no initialBytes', () => {
+    expect(initialState({})).toEqual({
+      mode: 'hex',
+      text: '',
+      bytes: null,
+      error: null,
+    });
+  });
+
+  it('encodes initial bytes as grouped hex when mode is hex', () => {
+    expect(initialState({ initialBytes: [0x89, 0x50, 0x4e, 0x47] })).toEqual({
+      mode: 'hex',
+      text: '89 50 4E 47',
+      bytes: [0x89, 0x50, 0x4e, 0x47],
+      error: null,
+    });
+  });
+
+  it('encodes initial bytes as base64 when mode is base64', () => {
+    expect(
+      initialState({ initialBytes: [0x48, 0x69], mode: 'base64' }),
+    ).toEqual({
+      mode: 'base64',
+      text: 'SGk=',
+      bytes: [0x48, 0x69],
+      error: null,
+    });
+  });
+
+  it('treats empty initial bytes the same as no bytes', () => {
+    expect(initialState({ initialBytes: [] })).toEqual({
+      mode: 'hex',
+      text: '',
+      bytes: null,
+      error: null,
+    });
+  });
+});
+
+describe('reduce: set-text', () => {
+  it('parses valid hex into bytes', () => {
+    const next = reduce(hexState(), { type: 'set-text', text: '89 50 4E 47' });
+    expect(next).toEqual({
+      mode: 'hex',
+      text: '89 50 4E 47',
+      bytes: [0x89, 0x50, 0x4e, 0x47],
+      error: null,
+    });
+  });
+
+  it('keeps invalid hex text but clears bytes and surfaces the parse error', () => {
+    const next = reduce(hexState(), { type: 'set-text', text: 'gg' });
+    expect(next).toEqual({
+      mode: 'hex',
+      text: 'gg',
+      bytes: null,
+      error: 'Hex input contains invalid characters.',
+    });
+  });
+
+  it('keeps trailing-nibble text but reports incomplete bytes', () => {
+    const next = reduce(hexState(), { type: 'set-text', text: '89 5' });
+    expect(next).toEqual({
+      mode: 'hex',
+      text: '89 5',
+      bytes: null,
+      error: 'Hex input must contain complete bytes.',
+    });
+  });
+
+  it('surfaces the empty-input error for cleared text', () => {
+    const next = reduce(hexState([0x89]), { type: 'set-text', text: '' });
+    expect(next).toEqual({
+      mode: 'hex',
+      text: '',
+      bytes: null,
+      error: 'Enter at least one byte.',
+    });
+  });
+
+  it('does not rewrite text (paste filter is responsible for that)', () => {
+    // Even though "DEAD" would canonicalise to "DE AD", set-text must
+    // preserve the user's exact text. Only normalize-paste rewrites it.
+    const next = reduce(hexState(), { type: 'set-text', text: 'DEAD' });
+    expect(next.text).toBe('DEAD');
+    expect(next.bytes).toEqual([0xde, 0xad]);
+  });
+});
+
+describe('reduce: normalize-paste', () => {
+  it('rewrites pasted hexdump into canonical grouped hex', () => {
+    const pasted =
+      '00000000  89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52  |.PNG........IHDR|';
+    const next = reduce(hexState(), { type: 'normalize-paste', text: pasted });
+    expect(next.text).toBe('89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52');
+    expect(next.bytes).toEqual([
+      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
+      0x49, 0x48, 0x44, 0x52,
+    ]);
+    expect(next.error).toBeNull();
+  });
+
+  it('rewrites pasted base64 into canonical base64', () => {
+    const state = initialState({ mode: 'base64' });
+    const next = reduce(state, {
+      type: 'normalize-paste',
+      text: '  SGVs\nbG8=  ',
+    });
+    expect(next.text).toBe('SGVsbG8=');
+    expect(next.bytes).toEqual([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
+  });
+
+  it('keeps the raw pasted text and reports the error when invalid', () => {
+    const next = reduce(hexState(), {
+      type: 'normalize-paste',
+      text: 'oh no',
+    });
+    expect(next.text).toBe('oh no');
+    expect(next.bytes).toBeNull();
+    expect(next.error).toBe('Hex input contains invalid characters.');
+  });
+});
+
+describe('reduce: switch-mode', () => {
+  it('converts valid bytes in place when switching hex -> base64', () => {
+    const start = reduce(hexState(), { type: 'set-text', text: '48 69' });
+    const next = reduce(start, { type: 'switch-mode', mode: 'base64' });
+    expect(next).toEqual({
+      mode: 'base64',
+      text: 'SGk=',
+      bytes: [0x48, 0x69],
+      error: null,
+    });
+  });
+
+  it('converts valid bytes in place when switching base64 -> hex', () => {
+    const start = reduce(initialState({ mode: 'base64' }), {
+      type: 'set-text',
+      text: 'SGk=',
+    });
+    const next = reduce(start, { type: 'switch-mode', mode: 'hex' });
+    expect(next).toEqual({
+      mode: 'hex',
+      text: '48 69',
+      bytes: [0x48, 0x69],
+      error: null,
+    });
+  });
+
+  it('clears text and error when current input is invalid', () => {
+    const invalid = reduce(hexState(), { type: 'set-text', text: '89 5' });
+    const next = reduce(invalid, { type: 'switch-mode', mode: 'base64' });
+    expect(next).toEqual({
+      mode: 'base64',
+      text: '',
+      bytes: null,
+      error: null,
+    });
+  });
+
+  it('is a no-op when the mode is unchanged', () => {
+    const state = reduce(hexState(), { type: 'set-text', text: '89 50' });
+    expect(reduce(state, { type: 'switch-mode', mode: 'hex' })).toBe(state);
+  });
+});
+
+describe('validate', () => {
+  it('passes when bytes are valid and non-empty', () => {
+    const state = reduce(hexState(), { type: 'set-text', text: '89 50' });
+    expect(validate(state)).toEqual({ ok: true, bytes: [0x89, 0x50] });
+  });
+
+  it('fails with the parse error when input is invalid', () => {
+    const state = reduce(hexState(), { type: 'set-text', text: 'gg' });
+    expect(validate(state)).toEqual({
+      ok: false,
+      reason: 'Hex input contains invalid characters.',
+    });
+  });
+
+  it('fails with the empty-input message when nothing is entered', () => {
+    expect(validate(hexState())).toEqual({
+      ok: false,
+      reason: 'Enter at least one byte.',
+    });
+  });
+});

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.',
+    });
+  });
+});