File size: 4,243 Bytes
21dd449 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 |
import { eventToGenerator } from "./eventToGenerator";
import { hexFromBytes } from "./hexFromBytes";
import { isFrontend } from "./isFrontend";
async function getWebWorkerCode() {
const sha256Module = await import("../vendor/hash-wasm/sha256-wrapper");
return URL.createObjectURL(new Blob([sha256Module.createSHA256WorkerCode()]));
}
const pendingWorkers: Worker[] = [];
const runningWorkers: Set<Worker> = new Set();
let resolve: () => void;
let waitPromise: Promise<void> = new Promise((r) => {
resolve = r;
});
async function getWorker(poolSize?: number): Promise<Worker> {
{
const worker = pendingWorkers.pop();
if (worker) {
runningWorkers.add(worker);
return worker;
}
}
if (!poolSize) {
const worker = new Worker(await getWebWorkerCode());
runningWorkers.add(worker);
return worker;
}
if (poolSize <= 0) {
throw new TypeError("Invalid webworker pool size: " + poolSize);
}
while (runningWorkers.size >= poolSize) {
await waitPromise;
}
const worker = new Worker(await getWebWorkerCode());
runningWorkers.add(worker);
return worker;
}
async function freeWorker(worker: Worker, poolSize: number | undefined): Promise<void> {
if (!poolSize) {
return destroyWorker(worker);
}
runningWorkers.delete(worker);
pendingWorkers.push(worker);
const r = resolve;
waitPromise = new Promise((r) => {
resolve = r;
});
r();
}
function destroyWorker(worker: Worker): void {
runningWorkers.delete(worker);
worker.terminate();
const r = resolve;
waitPromise = new Promise((r) => {
resolve = r;
});
r();
}
/**
* @returns hex-encoded sha
* @yields progress (0-1)
*/
export async function* sha256(
buffer: Blob,
opts?: { useWebWorker?: boolean | { minSize?: number; poolSize?: number }; abortSignal?: AbortSignal }
): AsyncGenerator<number, string> {
yield 0;
const maxCryptoSize =
typeof opts?.useWebWorker === "object" && opts?.useWebWorker.minSize !== undefined
? opts.useWebWorker.minSize
: 10_000_000;
if (buffer.size < maxCryptoSize && globalThis.crypto?.subtle) {
const res = hexFromBytes(
new Uint8Array(
await globalThis.crypto.subtle.digest("SHA-256", buffer instanceof Blob ? await buffer.arrayBuffer() : buffer)
)
);
yield 1;
return res;
}
if (isFrontend) {
if (opts?.useWebWorker) {
try {
const poolSize = typeof opts?.useWebWorker === "object" ? opts.useWebWorker.poolSize : undefined;
const worker = await getWorker(poolSize);
return yield* eventToGenerator<number, string>((yieldCallback, returnCallback, rejectCallack) => {
worker.addEventListener("message", (event) => {
if (event.data.sha256) {
freeWorker(worker, poolSize);
returnCallback(event.data.sha256);
} else if (event.data.progress) {
yieldCallback(event.data.progress);
try {
opts.abortSignal?.throwIfAborted();
} catch (err) {
destroyWorker(worker);
rejectCallack(err);
}
} else {
destroyWorker(worker);
rejectCallack(event);
}
});
worker.addEventListener("error", (event) => {
destroyWorker(worker);
rejectCallack(event.error);
});
worker.postMessage({ file: buffer });
});
} catch (err) {
console.warn("Failed to use web worker for sha256", err);
}
}
if (!wasmModule) {
wasmModule = await import("../vendor/hash-wasm/sha256-wrapper");
}
const sha256 = await wasmModule.createSHA256();
sha256.init();
const reader = buffer.stream().getReader();
const total = buffer.size;
let bytesDone = 0;
while (true) {
const { done, value } = await reader.read();
if (done) {
break;
}
sha256.update(value);
bytesDone += value.length;
yield bytesDone / total;
opts?.abortSignal?.throwIfAborted();
}
return sha256.digest("hex");
}
if (!cryptoModule) {
cryptoModule = await import("./sha256-node");
}
return yield* cryptoModule.sha256Node(buffer, { abortSignal: opts?.abortSignal });
}
// eslint-disable-next-line @typescript-eslint/consistent-type-imports
let cryptoModule: typeof import("./sha256-node");
// eslint-disable-next-line @typescript-eslint/consistent-type-imports
let wasmModule: typeof import("../vendor/hash-wasm/sha256-wrapper");
|