;
+
+interface SerializedError {
+ message: string;
+ stack?: string;
+ code?: string;
+}
+
+interface WorkerClientRequestPayload {
+ id: string;
+ action: string;
+ payload: P;
+}
+
+interface WorkerServerResponsePayload {
+ id: string;
+ result: R;
+ error: SerializedError;
+}
+
+export class WorkerClientBus {
+ private idPromiseMap = new Map void, (error: Error) => void]>();
+
+ constructor(private worker: Worker) {
+ worker.addEventListener('message', this.eventHandler);
+ }
+
+ eventHandler = (e: MessageEvent) => {
+ const { id, result, error } = e.data;
+ const actionPromise = this.idPromiseMap.get(id);
+ if (!actionPromise) {
+ console.error('cound not fetch worker promise for action: %s', id);
+ return;
+ }
+ this.idPromiseMap.delete(id);
+
+ const [resolve, reject] = actionPromise;
+ if (error) {
+ const wrappedError = new Error(error.message, { cause: error });
+ wrappedError.stack = error.stack;
+ Object.assign(wrappedError, { code: error.code ?? null });
+ reject(wrappedError);
+ } else {
+ resolve(result as never);
+ }
+ };
+
+ async request(actionName: T, payload: P): Promise {
+ return new Promise((resolve, reject) => {
+ const id = `request://${actionName}/${nanoid()}`;
+ this.idPromiseMap.set(id, [resolve, reject]);
+ this.worker.postMessage({
+ id,
+ action: actionName,
+ payload,
+ });
+ });
+ }
+}
+
+export class WorkerServerBus {
+ private handlers = new Map>();
+
+ addEventHandler(actionName: string, handler: WorkerServerHandler) {
+ this.handlers.set(actionName, handler as WorkerServerHandler);
+ }
+
+ onmessage = async (e: MessageEvent) => {
+ const { id, action, payload } = e.data;
+ const handler = this.handlers.get(action);
+
+ let result = null;
+ let error = null;
+
+ if (!handler) {
+ error = new Error('Handler missing for action ' + action);
+ } else {
+ try {
+ result = await handler(payload);
+ } catch (err: unknown) {
+ if (err instanceof DecryptError) {
+ error = err.toJSON();
+ } else {
+ error = err;
+ }
+ }
+ }
+
+ postMessage({ id, result, error });
+ };
+}
diff --git a/um-react/src/util/__tests__/ConcurrentQueue.test.ts b/um-react/src/util/__tests__/ConcurrentQueue.test.ts
new file mode 100644
index 0000000..5074953
--- /dev/null
+++ b/um-react/src/util/__tests__/ConcurrentQueue.test.ts
@@ -0,0 +1,109 @@
+import { ConcurrentQueue } from '../ConcurrentQueue';
+import { nextTickAsync } from '../nextTick';
+
+class SimpleQueue extends ConcurrentQueue {
+ handler(_item: T): Promise {
+ throw new Error('Method not overridden');
+ }
+}
+
+test('should be able to process the queue within limit', async () => {
+ const inputs: number[] = [];
+ const queuedResolver: (() => void)[] = [];
+ const queue = new SimpleQueue(3);
+
+ try {
+ vi.spyOn(queue, 'handler').mockImplementation((item) => {
+ inputs.push(item);
+ return new Promise((resolve, _reject) => {
+ queuedResolver.push(resolve);
+ });
+ });
+
+ const promises = [
+ // Add some values
+ queue.add(1),
+ queue.add(2),
+ queue.add(3),
+ queue.add(4),
+ queue.add(5),
+ ];
+
+ // Should queue 3 things at once
+ expect(queue.handler).toHaveBeenCalledTimes(3);
+ expect(inputs).toEqual([1, 2, 3]);
+
+ // Let first 3 go
+ for (let i = 0; i < 3; i++) {
+ queuedResolver[i]();
+ await promises[i];
+ }
+
+ // Wait till all fulfilled
+ while (queuedResolver.length !== 5) {
+ await nextTickAsync();
+ }
+
+ // Now it should've queued everything.
+ expect(inputs).toEqual([1, 2, 3, 4, 5]);
+ expect(queue.handler).toHaveBeenCalledTimes(5);
+
+ // Resolve everything
+ queuedResolver.forEach((resolve) => resolve());
+ await Promise.all(promises);
+ } finally {
+ vi.spyOn(queue, 'handler').mockRejectedValue(new Error('handler ran too late'));
+ queuedResolver.forEach((resolve) => resolve());
+ }
+});
+
+test('it should move on to the next item in the queue once failed', async () => {
+ const inputs: number[] = [];
+ const queuedResolver: (() => void)[] = [];
+ const queue = new SimpleQueue(3);
+
+ try {
+ vi.spyOn(queue, 'handler').mockImplementation((item) => {
+ if (item === 3) {
+ throw new Error('dummy error');
+ }
+
+ inputs.push(item);
+ return new Promise((resolve, _reject) => {
+ queuedResolver.push(() => resolve(item));
+ });
+ });
+
+ const promises = [
+ // Add some values
+ queue.add(1),
+ queue.add(2),
+ ];
+ const errorHandler = vi.fn();
+ const badPromise = queue.add(3);
+ badPromise.catch(errorHandler);
+ promises.push(queue.add(4));
+ promises.push(queue.add(5));
+
+ // Let first 2 be fulfilled
+ for (let i = 0; i < 2; i++) {
+ queuedResolver[i]();
+ await promises[i];
+ }
+
+ // Wait till all fulfilled
+ while (queuedResolver.length !== 4) {
+ await nextTickAsync();
+ }
+
+ // Should've moved on, as 3 will throw error
+ expect(queue.handler).toHaveBeenCalledTimes(5);
+ await expect(badPromise).rejects.toThrowError('dummy error');
+
+ queuedResolver.forEach((resolve) => resolve());
+ expect(Promise.all(promises)).resolves.toEqual([1, 2, 4, 5]);
+ } finally {
+ vi.spyOn(queue, 'handler').mockRejectedValue(new Error('handler ran too late'));
+ queuedResolver.forEach((resolve) => resolve());
+ }
+});
diff --git a/um-react/src/util/__tests__/DecryptionQueue.test.ts b/um-react/src/util/__tests__/DecryptionQueue.test.ts
new file mode 100644
index 0000000..4f2bf35
--- /dev/null
+++ b/um-react/src/util/__tests__/DecryptionQueue.test.ts
@@ -0,0 +1,32 @@
+import { DECRYPTION_WORKER_ACTION_NAME } from '~/decrypt-worker/constants';
+import { WorkerClientBus } from '../WorkerEventBus';
+import { DecryptionQueue } from '../DecryptionQueue';
+
+vi.mock('../WorkerEventBus', () => {
+ class MyWorkerClientBus {
+ request() {
+ throw new Error('request not mocked');
+ }
+ }
+
+ return { WorkerClientBus: MyWorkerClientBus };
+});
+
+test('should be able to forward request to worker client bus', async () => {
+ // This class is mocked
+ const bus = new WorkerClientBus(null as never);
+ vi.spyOn(bus, 'request').mockImplementation(
+ async (actionName: DECRYPTION_WORKER_ACTION_NAME, payload: unknown): Promise => {
+ return { actionName, payload };
+ }
+ );
+
+ const queue = new DecryptionQueue(bus, 1);
+ await expect(queue.add({ id: 'file://1', blobURI: 'blob://mock-file' })).resolves.toEqual({
+ actionName: DECRYPTION_WORKER_ACTION_NAME.DECRYPT,
+ payload: {
+ blobURI: 'blob://mock-file',
+ id: 'file://1',
+ },
+ });
+});
diff --git a/um-react/src/util/__tests__/MMKVParser.test.ts b/um-react/src/util/__tests__/MMKVParser.test.ts
new file mode 100644
index 0000000..e4eebcb
--- /dev/null
+++ b/um-react/src/util/__tests__/MMKVParser.test.ts
@@ -0,0 +1,19 @@
+import { MMKVParser } from '../MMKVParser';
+import { readFileSync } from 'node:fs';
+
+test('parse mmkv file as expected', () => {
+ const buff = readFileSync(__dirname + '/__fixture__/test.mmkv');
+ const view = new DataView(buff.buffer.slice(buff.byteOffset, buff.byteOffset + buff.byteLength));
+ expect(MMKVParser.toStringMap(view)).toEqual(
+ new Map([
+ ['key', 'value'],
+ [
+ 'Lorem Ipsum',
+ 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ' +
+ 'Vestibulum congue volutpat metus non molestie. Quisque id est sapien. ' +
+ 'Fusce eget tristique sem. Donec tellus lacus, viverra sed lectus eget, elementum ultrices dolor. ' +
+ 'Integer non urna justo.',
+ ],
+ ])
+ );
+});
diff --git a/um-react/src/util/__tests__/__fixture__/test.mmkv b/um-react/src/util/__tests__/__fixture__/test.mmkv
new file mode 100644
index 0000000..04a8a01
Binary files /dev/null and b/um-react/src/util/__tests__/__fixture__/test.mmkv differ
diff --git a/um-react/src/util/__tests__/enumObject.test.ts b/um-react/src/util/__tests__/enumObject.test.ts
new file mode 100644
index 0000000..64ab335
--- /dev/null
+++ b/um-react/src/util/__tests__/enumObject.test.ts
@@ -0,0 +1,24 @@
+import { enumObject } from '../objects';
+
+test('it should ignore and not crash with non-object', () => {
+ expect(Array.from(enumObject('string' as never))).toEqual([]);
+});
+
+test('it should ignore and not crash with null', () => {
+ expect(Array.from(enumObject(null))).toEqual([]);
+});
+
+test('it be able to iterate object', () => {
+ expect(Array.from(enumObject({ a: '1', b: '2' }))).toMatchInlineSnapshot(`
+ [
+ [
+ "a",
+ "1",
+ ],
+ [
+ "b",
+ "2",
+ ],
+ ]
+ `);
+});
diff --git a/um-react/src/util/__tests__/levenshtein.test.ts b/um-react/src/util/__tests__/levenshtein.test.ts
new file mode 100644
index 0000000..e3c5b1e
--- /dev/null
+++ b/um-react/src/util/__tests__/levenshtein.test.ts
@@ -0,0 +1,17 @@
+import { closestByLevenshtein, levenshtein } from '../levenshtein';
+
+test('levenshtein quick test', () => {
+ expect(levenshtein('cat', '')).toStrictEqual(3);
+ expect(levenshtein('', 'cat')).toStrictEqual(3);
+ expect(levenshtein('cat', 'cat')).toStrictEqual(0);
+ expect(levenshtein('cat', 'cut')).toStrictEqual(1);
+ expect(levenshtein('kitten', 'sitting')).toStrictEqual(3);
+ expect(levenshtein('tier', 'tor')).toStrictEqual(2);
+ expect(levenshtein('mississippi', 'swiss miss')).toStrictEqual(8);
+});
+
+test('closestByLevenshtein quick test', () => {
+ expect(closestByLevenshtein('cat', ['cut', 'dog', 'bat'])).toStrictEqual('cut');
+ expect(closestByLevenshtein('dag', ['dog', 'pumpkin'])).toStrictEqual('dog');
+ expect(closestByLevenshtein('hello', ['jello', 'yellow', 'bello'])).toStrictEqual('jello');
+});
diff --git a/um-react/src/util/__tests__/pathHelper.test.ts b/um-react/src/util/__tests__/pathHelper.test.ts
new file mode 100644
index 0000000..b8ac642
--- /dev/null
+++ b/um-react/src/util/__tests__/pathHelper.test.ts
@@ -0,0 +1,13 @@
+import { getFileName } from '../pathHelper';
+
+test('handle linux path', () => {
+ expect(getFileName('/path/to/file.bin')).toEqual('file.bin');
+});
+
+test('handle win32 path', () => {
+ expect(getFileName('C:\\system32\\file.bin')).toEqual('file.bin');
+});
+
+test('handle file name only as well', () => {
+ expect(getFileName('file.bin')).toEqual('file.bin');
+});
diff --git a/um-react/src/util/__tests__/splitN.ts.test.ts b/um-react/src/util/__tests__/splitN.ts.test.ts
new file mode 100644
index 0000000..448322b
--- /dev/null
+++ b/um-react/src/util/__tests__/splitN.ts.test.ts
@@ -0,0 +1,10 @@
+import { splitN } from '../splitN';
+
+test('some test cases', () => {
+ expect(splitN('1,2,3', ',', 2)).toEqual(['1', '2,3']);
+ expect(splitN('1,2,3', ',', 3)).toEqual(['1', '2', '3']);
+ expect(splitN('1,2,3', ',', 4)).toEqual(['1', '2', '3']);
+
+ expect(splitN('1,2,3', '.', 3)).toEqual(['1,2,3']);
+ expect(splitN('1,2,3', '?', 0)).toEqual(['1,2,3']);
+});
diff --git a/um-react/src/util/fnWrapper.ts b/um-react/src/util/fnWrapper.ts
new file mode 100644
index 0000000..8c3bdf4
--- /dev/null
+++ b/um-react/src/util/fnWrapper.ts
@@ -0,0 +1,20 @@
+function isPromise(p: unknown): p is Promise {
+ return !!p && typeof p === 'object' && 'then' in p && 'catch' in p && 'finally' in p;
+}
+
+export function wrapFunctionCall(pre: () => void, post: () => void, fn: () => R): R {
+ pre();
+
+ try {
+ const result = fn();
+
+ if (isPromise(result)) {
+ result.finally(post);
+ }
+
+ return result;
+ } catch (e) {
+ post();
+ throw e;
+ }
+}
diff --git a/um-react/src/util/formatHex.ts b/um-react/src/util/formatHex.ts
new file mode 100644
index 0000000..0d778c1
--- /dev/null
+++ b/um-react/src/util/formatHex.ts
@@ -0,0 +1,3 @@
+export function formatHex(value: number, len = 8) {
+ return '0x' + (value | 0).toString(16).padStart(len, '0');
+}
diff --git a/um-react/src/util/levenshtein.ts b/um-react/src/util/levenshtein.ts
new file mode 100644
index 0000000..340a057
--- /dev/null
+++ b/um-react/src/util/levenshtein.ts
@@ -0,0 +1,77 @@
+// translation of pseudocode from Wikipedia:
+import { stringToUTF8Bytes } from '~/decrypt-worker/util/utf8Encoder';
+
+// https://en.wikipedia.org/wiki/Levenshtein_distance#Iterative_with_two_matrix_rows
+export function levenshtein(str1: string, str2: string) {
+ if (str1 === str2) {
+ return 0;
+ }
+
+ if (str1.length === 0) {
+ return str2.length;
+ } else if (str2.length === 0) {
+ return str1.length;
+ }
+
+ // Convert them to Uint8Array to avoid expensive string APIs.
+ const s = stringToUTF8Bytes(str1.normalize().toLowerCase());
+ const t = stringToUTF8Bytes(str2.normalize().toLowerCase());
+ const m = s.byteLength;
+ const n = t.byteLength;
+
+ // create two work vectors of integer distances
+ let v0 = new Uint32Array(n + 1);
+ let v1 = new Uint32Array(n + 1);
+
+ // initialize v0 (the previous row of distances)
+ // this row is A[0][i]: edit distance from an empty s to t;
+ // that distance is the number of characters to append to s to make t.
+ for (let i = 0; i <= n; i++) {
+ v0[i] = i;
+ }
+
+ for (let i = 0; i < m; i++) {
+ // calculate v1 (current row distances) from the previous row v0
+
+ // first element of v1 is A[i + 1][0]
+ // edit distance is delete (i + 1) chars from s to match empty t
+ v1[0] = i + 1;
+
+ // use formula to fill in the rest of the row
+ for (let j = 0; j < n; j++) {
+ // calculating costs for A[i + 1][j + 1]
+ const deletionCost = v0[j + 1] + 1;
+ const insertionCost = v1[j] + 1;
+ const substitutionCost = v0[j] + (s[i] === t[j] ? 0 : 1);
+ v1[j + 1] = Math.min(deletionCost, insertionCost, substitutionCost);
+ }
+
+ // copy v1 (current row) to v0 (previous row) for next iteration
+ // since data in v1 is always invalidated, a swap without copy could be more efficient
+ [v0, v1] = [v1, v0];
+ }
+
+ // after the last swap, the results of v1 are now in v0
+ return v0[n];
+}
+
+export function closestByLevenshtein(str: string, candidates: string[]) {
+ // Faster than pre-calculate all and pass scores to Math.min.
+ const n = candidates.length;
+ if (n === 0) {
+ throw new Error('empty candidates');
+ }
+
+ let lowestIdx = 0;
+ let lowestScore = levenshtein(str, candidates[0]);
+
+ for (let i = 1; i < n; i++) {
+ const score = levenshtein(str, candidates[i]);
+ if (score < lowestScore) {
+ lowestScore = score;
+ lowestIdx = i;
+ }
+ }
+
+ return candidates[lowestIdx];
+}
diff --git a/um-react/src/util/logUtils.ts b/um-react/src/util/logUtils.ts
new file mode 100644
index 0000000..29430b5
--- /dev/null
+++ b/um-react/src/util/logUtils.ts
@@ -0,0 +1,45 @@
+import { wrapFunctionCall } from './fnWrapper';
+
+export function timedLogger(label: string, fn: () => R): R {
+ if (import.meta.env.ENABLE_PERF_LOG !== '1') {
+ return fn();
+ } else {
+ return wrapFunctionCall(
+ () => console.time(label),
+ () => console.timeEnd(label),
+ fn
+ );
+ }
+}
+
+export function withGroupedLogs(label: string, fn: () => R): R {
+ if (import.meta.env.ENABLE_PERF_LOG !== '1') {
+ return fn();
+ } else {
+ return wrapFunctionCall(
+ () => console.group(label),
+ () => (console.groupEnd as (label: string) => void)(label),
+ () => timedLogger(`${label}/total`, fn)
+ );
+ }
+}
+
+const noop = (..._args: unknown[]) => {
+ // noop
+};
+
+const dummyLogger = {
+ log: noop,
+ info: noop,
+ warn: noop,
+ debug: noop,
+ trace: noop,
+};
+
+export function getLogger() {
+ if (import.meta.env.ENABLE_PERF_LOG === '1') {
+ return window.console;
+ } else {
+ return dummyLogger;
+ }
+}
diff --git a/um-react/src/util/nextTick.ts b/um-react/src/util/nextTick.ts
new file mode 100644
index 0000000..0b50258
--- /dev/null
+++ b/um-react/src/util/nextTick.ts
@@ -0,0 +1,14 @@
+type NextTickFn = (callback: () => void) => void;
+
+/* c8 ignore start */
+const nextTickFn =
+ typeof setImmediate !== 'undefined'
+ ? (setImmediate as NextTickFn)
+ : typeof requestAnimationFrame !== 'undefined'
+ ? (requestAnimationFrame as NextTickFn)
+ : (setTimeout as NextTickFn);
+/* c8 ignore stop */
+
+export async function nextTickAsync() {
+ return new Promise((resolve) => nextTickFn(resolve));
+}
diff --git a/um-react/src/util/objects.ts b/um-react/src/util/objects.ts
new file mode 100644
index 0000000..ee7fe14
--- /dev/null
+++ b/um-react/src/util/objects.ts
@@ -0,0 +1,9 @@
+export function* enumObject(obj: Record | null | void): Generator<[string, T]> {
+ if (obj && typeof obj === 'object') {
+ for (const key in obj) {
+ yield [key, obj[key]];
+ }
+ }
+}
+
+export const { hasOwn } = Object;
diff --git a/um-react/src/util/pathHelper.ts b/um-react/src/util/pathHelper.ts
new file mode 100644
index 0000000..c50939b
--- /dev/null
+++ b/um-react/src/util/pathHelper.ts
@@ -0,0 +1,3 @@
+export function getFileName(path: string) {
+ return path.replace(/.*[\\/]/, '');
+}
diff --git a/um-react/src/util/splitN.ts b/um-react/src/util/splitN.ts
new file mode 100644
index 0000000..0b3d402
--- /dev/null
+++ b/um-react/src/util/splitN.ts
@@ -0,0 +1,20 @@
+export function splitN(str: string, sep: string, maxN: number) {
+ if (maxN <= 1) {
+ return [str];
+ }
+
+ const chunks: string[] = [];
+ const lenSep = sep.length;
+ let searchIdx = 0;
+ for (; maxN > 1; maxN--) {
+ const nextIdx = str.indexOf(sep, searchIdx);
+ if (nextIdx === -1) {
+ break;
+ }
+ chunks.push(str.slice(searchIdx, nextIdx));
+ searchIdx = nextIdx + lenSep;
+ }
+
+ chunks.push(str.slice(searchIdx));
+ return chunks;
+}
diff --git a/um-react/src/util/sqlite.ts b/um-react/src/util/sqlite.ts
new file mode 100644
index 0000000..f1c652c
--- /dev/null
+++ b/um-react/src/util/sqlite.ts
@@ -0,0 +1,15 @@
+import * as initSqlite from 'sql.js';
+
+const urlWasm = new URL('@nm/sql.js/dist/sql-wasm.wasm', import.meta.url).toString();
+
+export type SQLStatic = Awaited>;
+export type SQLDatabase = SQLStatic['Database']['prototype'];
+
+let sqlLoaderPromise: Promise | void;
+
+export async function loadSQL() {
+ if (!sqlLoaderPromise) {
+ sqlLoaderPromise = initSqlite.default({ locateFile: () => urlWasm });
+ }
+ return await sqlLoaderPromise;
+}
diff --git a/um-react/src/vite-env.d.ts b/um-react/src/vite-env.d.ts
new file mode 100644
index 0000000..11f02fe
--- /dev/null
+++ b/um-react/src/vite-env.d.ts
@@ -0,0 +1 @@
+///
diff --git a/um-react/tsconfig.json b/um-react/tsconfig.json
new file mode 100644
index 0000000..86d1a54
--- /dev/null
+++ b/um-react/tsconfig.json
@@ -0,0 +1,33 @@
+{
+ "compilerOptions": {
+ "target": "ESNext",
+ "lib": ["DOM", "DOM.Iterable", "ESNext"],
+ "types": ["vitest/globals", "@testing-library/jest-dom"],
+ "module": "ESNext",
+ "skipLibCheck": true,
+ /* Bundler mode */
+ "moduleResolution": "bundler",
+ "allowImportingTsExtensions": true,
+ "resolveJsonModule": true,
+ "isolatedModules": true,
+ "noEmit": true,
+ "jsx": "react-jsx",
+ /* Linting */
+ "strict": true,
+ "noUnusedLocals": true,
+ "noUnusedParameters": true,
+ "noFallthroughCasesInSwitch": true,
+ "baseUrl": ".",
+ "esModuleInterop": true,
+ "paths": {
+ "~/*": ["./src/*"],
+ "@nm/*": ["./node_modules/*"]
+ }
+ },
+ "include": ["src"],
+ "references": [
+ {
+ "path": "./tsconfig.node.json"
+ }
+ ]
+}
diff --git a/um-react/tsconfig.node.json b/um-react/tsconfig.node.json
new file mode 100644
index 0000000..b5a3431
--- /dev/null
+++ b/um-react/tsconfig.node.json
@@ -0,0 +1,12 @@
+{
+ "compilerOptions": {
+ "composite": true,
+ "skipLibCheck": true,
+ "module": "ESNext",
+ "moduleResolution": "bundler",
+ "allowSyntheticDefaultImports": true
+ },
+ "include": [
+ "vite.config.ts"
+ ]
+}
diff --git a/um-react/tsconfig.prod.json b/um-react/tsconfig.prod.json
new file mode 100644
index 0000000..a829226
--- /dev/null
+++ b/um-react/tsconfig.prod.json
@@ -0,0 +1,9 @@
+{
+ "extends": "./tsconfig",
+ "exclude": [
+ "./src/**/__tests__/**",
+ "./src/**/__mocks__/**",
+ "./src/test-utils/**",
+ "./src/**/*.test.{js,jsx,ts,tsx}"
+ ]
+}
\ No newline at end of file
diff --git a/um-react/vite.config.ts b/um-react/vite.config.ts
new file mode 100644
index 0000000..cec9341
--- /dev/null
+++ b/um-react/vite.config.ts
@@ -0,0 +1,108 @@
+import cp from 'node:child_process';
+import url from 'node:url';
+import path from 'node:path';
+import fs from 'node:fs';
+
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import wasm from 'vite-plugin-wasm';
+import replace from '@rollup/plugin-replace';
+import topLevelAwait from 'vite-plugin-top-level-await';
+import { VitePWA } from 'vite-plugin-pwa';
+
+const gitRoot = url.fileURLToPath(new URL('.', import.meta.url));
+const pkg = JSON.parse(fs.readFileSync(gitRoot + '/package.json', 'utf-8'));
+
+function command(cmd, dir = '') {
+ return cp.execSync(cmd, { cwd: path.join(gitRoot, dir), encoding: 'utf-8' }).trim();
+}
+
+const COMMAND_GIT_VERSION = 'git describe --long --dirty --tags --always';
+const shortCommit = command(COMMAND_GIT_VERSION);
+const version = `${pkg.version}-${shortCommit}`;
+
+// https://vitejs.dev/config/
+export default defineConfig({
+ worker: {
+ format: 'es',
+ },
+ server: {
+ fs: {
+ // Note:
+ // This is _insecure_, but is required to get pnpm link to work.
+ // strict: false,
+
+ allow: [
+ 'src',
+ 'node_modules',
+
+ // Allow pnpm to link.
+ process.env.LIB_PARAKEET_JS_DIR || '../libparakeet-js',
+ ],
+ },
+ },
+ base: './',
+ optimizeDeps: {
+ exclude: ['@jixun/libparakeet', 'sql.js'],
+ },
+ plugins: [
+ replace({
+ preventAssignment: true,
+ values: {
+ __APP_VERSION_SHORT__: pkg.version,
+ __APP_VERSION__: version,
+ },
+ }),
+ react(),
+ wasm(),
+ topLevelAwait(),
+ VitePWA({
+ registerType: 'prompt',
+ workbox: {
+ // Cache everything from dist
+ globPatterns: ['**/*.{js,css,html,ico,png,svg,wasm}'],
+ },
+ manifest: {
+ display: 'standalone',
+ name: '音乐解锁 (Unlock Music)',
+ short_name: '音乐解锁',
+ lang: 'zh-cmn-Hans-CN',
+ description: '在现代浏览器解锁已购的加密音乐！',
+ theme_color: '#ffffff',
+ icons: [
+ {
+ src: 'pwa-192x192.png',
+ sizes: '192x192',
+ type: 'image/png',
+ purpose: 'maskable',
+ },
+ {
+ src: 'pwa-512x512.png',
+ sizes: '512x512',
+ type: 'image/png',
+ },
+ ],
+ },
+ }),
+ ],
+ resolve: {
+ alias: {
+ '~': path.resolve(__dirname, 'src'),
+ '@nm': path.resolve(__dirname, 'node_modules'),
+ module: path.resolve(__dirname, 'src', 'dummy.mjs'),
+ },
+ },
+ build: {
+ outDir: '../src/renderer',
+ rollupOptions: {
+ output: {
+ manualChunks: {
+ reacts: ['react', 'react-dom', 'react-dropzone', 'react-promise-suspense', 'react-redux', '@reduxjs/toolkit'],
+ chakra: ['@chakra-ui/react', '@emotion/react', '@emotion/styled', 'framer-motion'],
+ icons: ['react-icons', '@chakra-ui/icons'],
+ utility: ['radash', 'nanoid', 'immer', 'react-syntax-highlighter'],
+ },
+ },
+ },
+ },
+});
diff --git a/um-react/vitest.config.ts b/um-react/vitest.config.ts
new file mode 100644
index 0000000..e7e0842
--- /dev/null
+++ b/um-react/vitest.config.ts
@@ -0,0 +1,43 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+ test: {
+ globals: true,
+ mockReset: true,
+ environment: 'jsdom',
+ setupFiles: ['src/test-utils/setup-jest.ts'],
+ alias: [
+ {
+ find: /^~\/(.*)/,
+ replacement: 'src/$1',
+ },
+ ],
+ // workaround: sql.js is not ESModule friendly, yet...
+ deps: {
+ inline: ['sql.js'],
+ },
+ api: {
+ port: 5174, // vite port + 1
+ },
+ coverage: {
+ exclude: [
+ // default rules
+ 'coverage/**',
+ 'dist/**',
+ 'packages/*/test{,s}/**',
+ '**/*.d.ts',
+ 'cypress/**',
+ 'test{,s}/**',
+ 'test{,-*}.{js,cjs,mjs,ts,tsx,jsx}',
+ '**/*{.,-}test.{js,cjs,mjs,ts,tsx,jsx}',
+ '**/*{.,-}spec.{js,cjs,mjs,ts,tsx,jsx}',
+ '**/__tests__/**',
+ '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build}.config.*',
+ '**/.{eslint,mocha,prettier}rc.{js,cjs,yml}',
+
+ // custom ones
+ 'src/test-utils/**',
+ ],
+ },
+ },
+});
+