@seedprotocol/sdk 0.4.7 → 0.4.8

package/dist/FileManager-Wthr5yHO.js

@@ -0,0 +1,1142 @@
+import { a3 as saveAppState, C as BaseFileManager } from './index-j8WN8W6V.js';
+import debug from 'debug';
+import path from 'path-browserify';
+import 'xstate';
+import 'drizzle-orm/sqlite-core';
+import 'drizzle-orm';
+import 'nanoid';
+import 'nanoid-dictionary';
+import 'ethers';
+import 'pluralize';
+import 'rxjs';
+import 'lodash-es';
+import 'drizzle-orm/casing';
+import 'eventemitter3';
+import 'arweave';
+import '@sinclair/typebox';
+
+var filesDownload = `(
+  ${function () {
+    const identifyString = (str) => {
+        try {
+            JSON.parse(str);
+            return 'json';
+        }
+        catch (e) {
+            // Not JSON
+        }
+        if (!str) {
+            return;
+        }
+        if (str.trim().startsWith('<') && str.trim().endsWith('>')) {
+            return 'html';
+        }
+        // Simple markdown checks (very naive)
+        if (/^#{1,6}\s|^-{3,}|\*{3,}|^-{1,2}\s|\*\s/.test(str)) {
+            return 'markdown';
+        }
+        if (/^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/.test(str)) {
+            return 'base64';
+        }
+        // Default to plain text if unsure
+        return 'text';
+    };
+    const getMimeType = (base64) => {
+        if (!base64) {
+            return null;
+        }
+        const result = base64.match(/^data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,/);
+        if (result && result.length > 1) {
+            return result[1];
+        }
+        else {
+            return null; // MIME type could not be determined
+        }
+    };
+    const getDataTypeFromString = (data) => {
+        const nonImageBase64Regex = /^(?!data:image\/(?:jpeg|png|gif|bmp|webp);base64,)[A-Za-z0-9+/=]+$/;
+        if (nonImageBase64Regex.test(data)) {
+            return 'base64';
+        }
+        // Regular expression for base64 (simple version, checking for base64 format)
+        const imageBase64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/;
+        if (imageBase64Regex.test(data)) {
+            return 'imageBase64';
+        }
+        // Regular expression for URL (simple version, checking for common URL format)
+        const urlRegex = /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/;
+        if (urlRegex.test(data)) {
+            return 'url';
+        }
+        return null;
+    };
+    const isBinary = (arrayBuffer) => {
+        const view = new Uint8Array(arrayBuffer);
+        let nonTextCount = 0;
+        const threshold = 0.2; // Adjust as needed (e.g., 20% non-text implies binary)
+        for (let i = 0; i < view.length; i++) {
+            const byte = view[i];
+            // ASCII printable characters (32-126) and common whitespace (9, 10, 13)
+            if ((byte >= 32 && byte <= 126) || // Printable ASCII
+                byte === 9 || byte === 10 || byte === 13 // Tab, LF, CR
+            ) {
+                continue;
+            }
+            nonTextCount++;
+            if (nonTextCount / view.length > threshold) {
+                return true; // More than threshold are non-text bytes
+            }
+        }
+        return false; // Fewer than threshold are non-text bytes
+    };
+    const saveBufferToOPFS = async (filePath, buffer) => {
+        // Access the OPFS root directory
+        const rootHandle = await navigator.storage.getDirectory();
+        // Split the filePath into directory segments and file name
+        const segments = filePath.split('/').filter(Boolean);
+        const fileName = segments.pop(); // Extract the file name
+        if (!fileName) {
+            throw new Error('Invalid file path: No file name provided.');
+        }
+        // Traverse or create directories as needed
+        let currentDirHandle = rootHandle;
+        for (const segment of segments) {
+            currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
+        }
+        // Create or open the file in OPFS
+        const fileHandleAsync = await currentDirHandle.getFileHandle(fileName, { create: true });
+        const fileHandle = await fileHandleAsync.createSyncAccessHandle();
+        // Write the buffer to the file
+        fileHandle.write(buffer);
+        fileHandle.flush();
+        fileHandle.close();
+    };
+    const getFilesPath = (filesRoot, ...parts) => {
+        const root = filesRoot.replace(/\/$/, '');
+        return [root, ...parts].filter(Boolean).join('/').replace(/\/+/g, '/');
+    };
+    const downloadFiles = async ({ transactionIds, arweaveHost, filesRoot = '/files', }) => {
+        let arrayBuffer;
+        for (const transactionId of transactionIds) {
+            try {
+                const response = await fetch(`https://${arweaveHost}/raw/${transactionId}`);
+                arrayBuffer = await response.arrayBuffer();
+            }
+            catch (error) {
+                globalThis.postMessage({
+                    message: 'excludeTransaction',
+                    transactionId,
+                });
+                continue;
+            }
+            let dataString;
+            const isBinaryData = isBinary(arrayBuffer);
+            if (!isBinaryData) {
+                const decoder = new TextDecoder('utf-8');
+                const text = decoder.decode(arrayBuffer);
+                dataString = text;
+            }
+            if (dataString && dataString.startsWith('===FILE_SEPARATOR===')) {
+                const dataStringParts = dataString
+                    .split('===FILE_SEPARATOR===')
+                    .slice(1);
+                if (dataStringParts.length % 2 !== 0) {
+                    throw new Error('Input array must have an even number of elements.');
+                }
+                for (let i = 0; i < dataStringParts.length; i += 2) {
+                    const contentType = dataStringParts[i];
+                    const content = dataStringParts[i + 1];
+                    const encoder = new TextEncoder();
+                    if (contentType === 'html') {
+                        const fileName = `${transactionId}.html`;
+                        const buffer = encoder.encode(content);
+                        saveBufferToOPFS(getFilesPath(filesRoot, 'html', fileName), buffer);
+                    }
+                    if (contentType === 'json') {
+                        const fileName = `${transactionId}.json`;
+                        const buffer = encoder.encode(content);
+                        saveBufferToOPFS(getFilesPath(filesRoot, 'json', fileName), buffer);
+                    }
+                }
+                continue;
+            }
+            if (!dataString && arrayBuffer) {
+                saveBufferToOPFS(getFilesPath(filesRoot, 'images', transactionId), new Uint8Array(arrayBuffer));
+                continue;
+            }
+            if (!dataString) {
+                continue;
+            }
+            let contentType = identifyString(dataString);
+            if (contentType !== 'json' &&
+                contentType !== 'base64' &&
+                contentType !== 'html') {
+                const possibleImageType = getDataTypeFromString(dataString);
+                if (!possibleImageType) {
+                    continue;
+                }
+                contentType = possibleImageType;
+            }
+            if (contentType === 'url') {
+                const url = dataString;
+                let buffer;
+                try {
+                    const response = await fetch(url);
+                    buffer = await response.arrayBuffer();
+                }
+                catch (error) {
+                    globalThis.postMessage({
+                        message: 'excludeTransaction',
+                        transactionId,
+                    });
+                    continue;
+                }
+                const bufferUint8Array = new Uint8Array(buffer);
+                // Extract the file extension from the URL
+                const extensionMatch = url.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i);
+                if (!extensionMatch) {
+                    throw new Error('Unable to determine the file extension from the URL.');
+                }
+                extensionMatch[0]; // e.g., ".jpg"
+                // Set the file name (you can customize this)
+                // const fileNameFromUrl = `${transactionId}${fileExtension}`
+                await saveBufferToOPFS(getFilesPath(filesRoot, 'images', transactionId), bufferUint8Array);
+                continue;
+            }
+            const mimeType = getMimeType(dataString);
+            let fileExtension = mimeType;
+            if (fileExtension && fileExtension?.startsWith('image')) {
+                fileExtension = fileExtension.replace('image/', '');
+            }
+            let fileName = transactionId;
+            if (contentType === 'base64') {
+                if (fileExtension) {
+                    fileName += `.${fileExtension}`;
+                }
+                // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
+                const base64Data = dataString.split(',').pop() || '';
+                // Decode the Base64 string to binary
+                const binaryString = atob(base64Data);
+                const length = binaryString.length;
+                const binaryData = new Uint8Array(length);
+                for (let i = 0; i < length; i++) {
+                    binaryData[i] = binaryString.charCodeAt(i);
+                }
+                await saveBufferToOPFS(getFilesPath(filesRoot, 'images', fileName), binaryData);
+            }
+            if (contentType === 'html') {
+                fileName += '.html';
+                const encoder = new TextEncoder();
+                const buffer = encoder.encode(dataString);
+                await saveBufferToOPFS(getFilesPath(filesRoot, 'html', fileName), buffer);
+            }
+            if (contentType === 'json') {
+                fileName += '.json';
+                const encoder = new TextEncoder();
+                const buffer = encoder.encode(dataString);
+                await saveBufferToOPFS(getFilesPath(filesRoot, 'json', fileName), buffer);
+            }
+        }
+    };
+    onmessage = async (e) => {
+        const { debug, filesRoot } = e.data;
+        if (!debug) {
+            console.log = () => { };
+        }
+        await downloadFiles({ ...e.data, filesRoot });
+        globalThis.postMessage({
+            message: 'filesDownload onmessage done',
+            done: true,
+        });
+    };
+}.toString()}
+)()`;
+
+const logger$2 = debug('seedSdk:browser:workers:FileDownloader');
+class FileDownloader {
+    constructor() {
+        this.workersArchive = [];
+        this.downloadAll = async ({ transactionIds, arweaveHost, excludedTransactions }) => {
+            if (this.workersArchive.length > 0) {
+                for (let i = 0; i < this.workersArchive.length; i++) {
+                    this.workersArchive[i].terminate();
+                    delete this.workersArchive[i];
+                }
+                this.workersArchive = [];
+            }
+            const worker = new Worker(this.workerBlobUrl);
+            this.workersArchive.push(worker);
+            const localExcludedTransactions = new Set(excludedTransactions);
+            return new Promise((resolve, reject) => {
+                worker.onmessage = (e) => {
+                    logger$2('filesDownload main thread onmessage', e.data);
+                    if (e.data.message === 'excludeTransaction') {
+                        localExcludedTransactions.add(e.data.transactionId);
+                    }
+                    if (e.data.done) {
+                        saveAppState('excludedTransactions', JSON.stringify(Array.from(localExcludedTransactions)))
+                            .then(() => {
+                            resolve(e.data);
+                        })
+                            .catch((error) => {
+                            reject(error);
+                        });
+                    }
+                    if (e.data.error) {
+                        reject(e.data.error);
+                    }
+                };
+                worker.postMessage({
+                    transactionIds,
+                    arweaveHost,
+                    debug: logger$2.enabled,
+                    filesRoot: BaseFileManager.getWorkingDir(),
+                });
+            });
+        };
+        this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+        this.workerBlobUrl = globalThis.URL.createObjectURL(new Blob([filesDownload], { type: 'application/javascript' }));
+    }
+}
+
+var imageResize = `(
+  ${function () {
+    async function listFilesInDirectory(directoryHandle) {
+        const entries = [];
+        for await (const [name, handle] of directoryHandle.entries()) {
+            entries.push({
+                name,
+                kind: handle.kind,
+            });
+        }
+        return entries;
+    }
+    const getFileHandle = async (path, rootHandle = null) => {
+        // Split the path into segments
+        const segments = path.split('/').filter(Boolean);
+        // Start from the root directory if not provided
+        if (!rootHandle) {
+            rootHandle = await navigator.storage.getDirectory();
+        }
+        let currentHandle = rootHandle;
+        // Traverse the path segments
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            const isLastSegment = i === segments.length - 1;
+            try {
+                for await (const [name, handle] of currentHandle.entries()) {
+                    if (name !== segment) {
+                        continue;
+                    }
+                    if (isLastSegment) {
+                        if (handle.kind === 'file') {
+                            return handle; // Return the file handle if found
+                        }
+                        else {
+                            throw new Error(`Path '${path}' refers to a directory, not a file.`);
+                        }
+                    }
+                    else if (handle.kind === 'directory') {
+                        currentHandle = handle; // Traverse into the directory
+                    }
+                    else {
+                        throw new Error(`Invalid path segment '${segment}'`);
+                    }
+                }
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === 'NotFoundError') {
+                    throw new Error(`Path '${path}' does not exist.`);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        throw new Error(`Path '${path}' could not be resolved.`);
+    };
+    async function getFileFromOPFS(path) {
+        const fileHandleAsync = await getFileHandle(path);
+        const file = await fileHandleAsync.getFile();
+        return file;
+    }
+    const DEFAULT_CONFIG = {
+        argorithm: 'null',
+        processByHalf: true,
+        quality: 0.5,
+        maxWidth: 800,
+        maxHeight: 600,
+        debug: false,
+        mimeType: 'image/jpeg',
+    };
+    function isIos() {
+        if (typeof navigator === 'undefined')
+            return false;
+        if (!navigator.userAgent)
+            return false;
+        return /iPad|iPhone|iPod/.test(navigator.userAgent);
+    }
+    const getTargetHeight = (srcHeight, scale, config) => {
+        return Math.min(Math.floor(srcHeight * scale), config.maxHeight);
+    };
+    const findMaxWidth = (config, canvas) => {
+        //Let's find the max available width for scaled image
+        const ratio = canvas.width / canvas.height;
+        let mWidth = Math.min(canvas.width, config.maxWidth, ratio * config.maxHeight);
+        if (config.maxSize &&
+            config.maxSize > 0 &&
+            config.maxSize < (canvas.width * canvas.height) / 1000)
+            mWidth = Math.min(mWidth, Math.floor((config.maxSize * 1000) / canvas.height));
+        if (!!config.scaleRatio)
+            mWidth = Math.min(mWidth, Math.floor(config.scaleRatio * canvas.width));
+        const rHeight = getTargetHeight(canvas.height, mWidth / canvas.width, config);
+        // console.log(
+        //   'browser-image-resizer: original image size = ' +
+        //   canvas.width +
+        //   ' px (width) X ' +
+        //   canvas.height +
+        //   ' px (height)'
+        // );
+        // console.log(
+        //   'browser-image-resizer: scaled image size = ' +
+        //   mWidth +
+        //   ' px (width) X ' +
+        //   rHeight +
+        //   ' px (height)'
+        // );
+        if (mWidth <= 0) {
+            mWidth = 1;
+            console.warn("browser-image-resizer: image size is too small");
+        }
+        if (isIos() && mWidth * rHeight > 167777216) {
+            console.error("browser-image-resizer: image size is too large for iOS WebKit.", mWidth, rHeight);
+            throw new Error("browser-image-resizer: image size is too large for iOS WebKit.");
+        }
+        return mWidth;
+    };
+    /**
+    * Hermite resize, multicore version - fast image resize/resample using Hermite filter.
+    */
+    const resample = (srcCanvas, destCanvas, config) => {
+        return new Promise((resolve, reject) => {
+            const ratio_h = srcCanvas.height / destCanvas.height;
+            const cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+            //prepare source and target data for workers
+            const ctx = srcCanvas.getContext('2d');
+            if (!ctx)
+                return reject('Canvas is empty (resample)');
+            const data_part = [];
+            const block_height = Math.ceil(srcCanvas.height / cores / 2) * 2;
+            let end_y = -1;
+            for (let c = 0; c < cores; c++) {
+                //source
+                const offset_y = end_y + 1;
+                if (offset_y >= srcCanvas.height) {
+                    //size too small, nothing left for this core
+                    continue;
+                }
+                end_y = Math.min(offset_y + block_height - 1, srcCanvas.height - 1);
+                const current_block_height = Math.min(block_height, srcCanvas.height - offset_y);
+                data_part.push({
+                    source: ctx.getImageData(0, offset_y, srcCanvas.width, block_height),
+                    startY: Math.ceil(offset_y / ratio_h),
+                    height: current_block_height
+                });
+            }
+            //start
+            const destCtx = destCanvas.getContext('2d');
+            if (!destCtx)
+                return reject('Canvas is empty (resample dest)');
+            for (let c = 0; c < data_part.length; c++) {
+                //draw
+                const height_part = Math.ceil(data_part[c].height / ratio_h);
+                const target = destCtx.createImageData(destCanvas.width, height_part);
+                // target.data.set(event.data.target);
+                destCtx.putImageData(target, 0, data_part[c].startY);
+            }
+        });
+    };
+    /**
+     * Hermite resize - fast image resize/resample using Hermite filter. 1 cpu version!
+     */
+    const resampleSingle = (srcCanvasData, destCanvasData) => {
+        const ratio_w = srcCanvasData.width / destCanvasData.width;
+        const ratio_h = srcCanvasData.height / destCanvasData.height;
+        const ratio_w_half = Math.ceil(ratio_w / 2);
+        const ratio_h_half = Math.ceil(ratio_h / 2);
+        const data = srcCanvasData.data;
+        const data2 = destCanvasData.data;
+        for (let j = 0; j < destCanvasData.height; j++) {
+            for (let i = 0; i < destCanvasData.width; i++) {
+                const x2 = (i + j * destCanvasData.width) * 4;
+                let weight = 0;
+                let weights = 0;
+                let weights_alpha = 0;
+                let gx_r = 0;
+                let gx_g = 0;
+                let gx_b = 0;
+                let gx_a = 0;
+                const center_y = j * ratio_h;
+                const xx_start = Math.floor(i * ratio_w);
+                const xx_stop = Math.min(Math.ceil((i + 1) * ratio_w), srcCanvasData.width);
+                const yy_start = Math.floor(j * ratio_h);
+                const yy_stop = Math.min(Math.ceil((j + 1) * ratio_h), srcCanvasData.height);
+                for (let yy = yy_start; yy < yy_stop; yy++) {
+                    let dy = Math.abs(center_y - yy) / ratio_h_half;
+                    let center_x = i * ratio_w;
+                    let w0 = dy * dy; //pre-calc part of w
+                    for (let xx = xx_start; xx < xx_stop; xx++) {
+                        let dx = Math.abs(center_x - xx) / ratio_w_half;
+                        let w = Math.sqrt(w0 + dx * dx);
+                        if (w >= 1) {
+                            //pixel too far
+                            continue;
+                        }
+                        //hermite filter
+                        weight = 2 * w * w * w - 3 * w * w + 1;
+                        let pos_x = 4 * (xx + yy * srcCanvasData.width);
+                        //alpha
+                        gx_a += weight * data[pos_x + 3];
+                        weights_alpha += weight;
+                        //colors
+                        if (data[pos_x + 3] < 255)
+                            weight = weight * data[pos_x + 3] / 250;
+                        gx_r += weight * data[pos_x];
+                        gx_g += weight * data[pos_x + 1];
+                        gx_b += weight * data[pos_x + 2];
+                        weights += weight;
+                    }
+                }
+                data2[x2] = gx_r / weights;
+                data2[x2 + 1] = gx_g / weights;
+                data2[x2 + 2] = gx_b / weights;
+                data2[x2 + 3] = gx_a / weights_alpha;
+            }
+        }
+    };
+    /**
+    * Hermite resize. Detect cpu count and use best option for user.
+    */
+    const resampleAuto = (srcCanvas, destCanvas, config) => {
+        if (!!globalThis.Worker && navigator.hardwareConcurrency > 1 && config?.argorithm !== 'hermite_single') {
+            //workers supported and we have at least 2 cpu cores - using multithreading
+            return resample(srcCanvas, destCanvas);
+        }
+        else {
+            //1 cpu version
+            const { srcImgData, destImgData } = getImageData(srcCanvas, destCanvas);
+            resampleSingle(srcImgData, destImgData);
+            destCanvas.getContext('2d').putImageData(destImgData, 0, 0);
+            return;
+        }
+    };
+    async function scaleCanvasWithAlgorithm(canvas, config) {
+        const scale = config.outputWidth / canvas.width;
+        const scaled = new OffscreenCanvas(Math.floor(config.outputWidth), getTargetHeight(canvas.height, scale, config));
+        switch (config.algorithm) {
+            case 'hermite': {
+                await resampleAuto(canvas, scaled, config);
+                break;
+            }
+            case 'hermite_single': {
+                const { srcImgData, destImgData } = getImageData(canvas, scaled);
+                resampleSingle(srcImgData, destImgData);
+                scaled?.getContext('2d')?.putImageData(destImgData, 0, 0);
+                break;
+            }
+            case 'bilinear': {
+                // const { srcImgData, destImgData } = getImageData(canvas, scaled);
+                // bilinear(srcImgData, destImgData, scale);
+                // scaled?.getContext('2d')?.putImageData(destImgData, 0, 0);
+                break;
+            }
+            default: {
+                scaled.getContext('2d')?.drawImage(canvas, 0, 0, scaled.width, scaled.height);
+                break;
+            }
+        }
+        return scaled;
+    }
+    const getHalfScaleCanvas = (src) => {
+        const half = new OffscreenCanvas(src.width / 2, src.height / 2);
+        half
+            ?.getContext('2d')
+            ?.drawImage(src, 0, 0, half.width, half.height);
+        return half;
+    };
+    const getImageData = (canvas, scaled) => {
+        const srcImgData = canvas
+            ?.getContext('2d')
+            ?.getImageData(0, 0, canvas.width, canvas.height);
+        const destImgData = scaled
+            ?.getContext('2d')
+            ?.createImageData(scaled.width, scaled.height);
+        if (!srcImgData || !destImgData)
+            throw Error('Canvas is empty (scaleCanvasWithAlgorithm). You should run this script after the document is ready.');
+        return { srcImgData, destImgData };
+    };
+    async function saveBlobToOPFS(filePath, blob) {
+        // Access the OPFS root directory
+        const rootHandle = await navigator.storage.getDirectory();
+        // Split the filePath into directory segments and file name
+        const segments = filePath.split('/').filter(Boolean);
+        const fileName = segments.pop(); // Extract the file name
+        if (!fileName) {
+            throw new Error('Invalid file path: No file name provided.');
+        }
+        // Traverse or create directories as needed
+        let currentDirHandle = rootHandle;
+        for (const segment of segments) {
+            currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
+        }
+        // Create or open the file in OPFS
+        const fileHandle = await currentDirHandle.getFileHandle(fileName, { create: true });
+        // Write the Blob to the file
+        const writableStream = await fileHandle.createWritable();
+        await writableStream.write(blob);
+        await writableStream.close();
+    }
+    const imageResize = async (filePath, width, height) => {
+        const config = {
+            ...DEFAULT_CONFIG,
+            algorithm: 'hermite_single',
+            mimeType: 'image/webp',
+            maxWidth: width,
+            maxHeight: height,
+        };
+        const rootHandle = await navigator.storage.getDirectory();
+        // List files in the root directory
+        await listFilesInDirectory(rootHandle);
+        const file = await getFileFromOPFS(filePath);
+        const imageBitmap = await createImageBitmap(file);
+        let converting;
+        if (isIos() && imageBitmap.width * imageBitmap.height > 16777216) {
+            const scale = Math.sqrt(16777216 / (imageBitmap.width * imageBitmap.height));
+            converting = new OffscreenCanvas(Math.floor(imageBitmap.width * scale), Math.floor(imageBitmap.height * scale));
+            converting.getContext('2d')?.drawImage(imageBitmap, 0, 0, converting.width, converting.height);
+        }
+        else {
+            converting = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
+            converting.getContext('2d')?.drawImage(imageBitmap, 0, 0);
+        }
+        const maxWidth = findMaxWidth(config, converting);
+        if (!maxWidth) {
+            throw Error(`browser-image-resizer: maxWidth is ${maxWidth}!!`);
+        }
+        while (config.processByHalf && converting.width >= 2 * maxWidth) {
+            converting = getHalfScaleCanvas(converting);
+        }
+        if (converting.width > maxWidth) {
+            converting = await scaleCanvasWithAlgorithm(converting, Object.assign(config, { outputWidth: maxWidth }));
+        }
+        if (config.mimeType === null) {
+            return converting;
+        }
+        const resizedBlob = await converting.convertToBlob({ type: config.mimeType, quality: config.quality });
+        const pathSegments = filePath.split('/');
+        const fileName = pathSegments.pop();
+        if (!fileName) {
+            throw Error('Invalid file path: No file name provided.');
+        }
+        const newSegments = [
+            ...pathSegments,
+            width,
+        ];
+        const fileNameParts = fileName.split('.');
+        const newFileName = `${fileNameParts[0]}.webp`;
+        const newDirPath = newSegments.join('/');
+        const newFilePath = `${newDirPath}/${newFileName}`;
+        // Save resized image to OPFS with new name
+        await saveBlobToOPFS(newFilePath, resizedBlob);
+        globalThis.postMessage({
+            done: true,
+            filePath: newFilePath,
+        });
+    };
+    onmessage = async (e) => {
+        const { filePath, width, height, debug } = e.data;
+        if (!debug) {
+            console.log = () => { };
+        }
+        await imageResize(filePath, width, height);
+    };
+}.toString()}
+)()`;
+
+const logger$1 = debug('seedSdk:browser:workers:ImageResizer');
+class ImageResizer {
+    constructor() {
+        this.workersArchive = new Map();
+        this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+        this.workerBlobUrl = globalThis.URL.createObjectURL(new Blob([imageResize], { type: 'application/javascript' }));
+    }
+    async resize({ filePath, width, height }) {
+        if (this.workersArchive.has(filePath)) {
+            const savedWorker = this.workersArchive.get(filePath);
+            savedWorker?.terminate();
+            logger$1('[ImageResizer.resize] Terminated worker for filePath due to incoming request', filePath);
+            this.workersArchive.delete(filePath);
+        }
+        const worker = new Worker(this.workerBlobUrl);
+        this.workersArchive.set(filePath, worker);
+        return new Promise((resolve, reject) => {
+            worker.onmessage = (e) => {
+                logger$1('[ImageResizer.resize] main thread onmessage', e.data);
+                if (e.data.done) {
+                    const savedWorker = this.workersArchive.get(filePath);
+                    savedWorker?.terminate();
+                    logger$1('[ImageResizer.resize] Terminated worker for filePath due to done', filePath);
+                    this.workersArchive.delete(filePath);
+                    resolve(e.data);
+                }
+                if (e.data.error) {
+                    reject(e.data.error);
+                }
+            };
+            worker.postMessage({
+                filePath,
+                width,
+                height,
+                debug: logger$1.enabled,
+            });
+        });
+    }
+    async resizeAll({ width, height }) {
+        const fs = await BaseFileManager.getFs();
+        const imageDir = BaseFileManager.getFilesPath('images');
+        let imageFilesStats = await fs.promises.readdir(imageDir, {
+            withFileTypes: true
+        });
+        imageFilesStats = imageFilesStats.filter((file) => file.isFile());
+        const imageFiles = imageFilesStats.map((file) => file.path);
+        const widthDir = `${imageDir}/${width}`;
+        await BaseFileManager.createDirIfNotExists(widthDir);
+        for (const imageFile of imageFiles) {
+            const resizedImageExists = await BaseFileManager.pathExists(`${widthDir}/${imageFile}`);
+            if (!resizedImageExists) {
+                await this.resize({ filePath: `${imageDir}/${imageFile}`, width, height });
+            }
+        }
+    }
+}
+
+const logger = debug('seedSdk:browser:helpers:FileManager');
+class FileManager extends BaseFileManager {
+    static async getFs() {
+        if (!this.zenfsCache) {
+            this.zenfsCache = await import('@zenfs/core');
+        }
+        return this.zenfsCache;
+    }
+    static getFsSync() {
+        if (!this.zenfsCache) {
+            throw new Error('File system not initialized. Call getFs() or initializeFileSystem() first.');
+        }
+        return this.zenfsCache;
+    }
+    static async getContentUrlFromPath(path) {
+        const fileExists = await this.pathExists(path);
+        if (fileExists) {
+            const file = await this.readFile(path);
+            return URL.createObjectURL(file);
+        }
+    }
+    static async initializeFileSystem(workingDir) {
+        const zenfs = await this.getFs();
+        const zenfsDomMod = await import('@zenfs/dom');
+        const { WebAccess } = zenfsDomMod;
+        const { configureSingle } = zenfs;
+        const handle = await navigator.storage.getDirectory();
+        // await configure({
+        //   mounts: {
+        //     '/': {
+        //       backend: WebAccess,
+        //       handle,
+        //     },
+        //   },
+        //   disableUpdateOnRead: true,
+        //   onlySyncOnClose: true,
+        // })
+        await configureSingle({
+            backend: WebAccess,
+            handle,
+        });
+        // Cache is already set in getFs(), so no need to set it again
+    }
+    static async downloadAllFiles({ transactionIds, arweaveHost, excludedTransactions, }) {
+        const fileDownloader = new FileDownloader();
+        await fileDownloader.downloadAll({ transactionIds, arweaveHost, excludedTransactions });
+    }
+    static async resizeImage({ filePath, width, height }) {
+        const imageResizer = new ImageResizer();
+        await imageResizer.resize({ filePath, width, height });
+    }
+    static async resizeAllImages({ width, height }) {
+        const imageResizer = new ImageResizer();
+        await imageResizer.resizeAll({ width, height });
+    }
+    static async listImageFiles() {
+        const imageDir = BaseFileManager.getFilesPath('images');
+        const exists = await this.pathExists(imageDir);
+        if (!exists) {
+            return [];
+        }
+        const zenfs = await this.getFs();
+        const entries = await zenfs.promises.readdir(imageDir, { withFileTypes: true });
+        return entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+    }
+    static async pathExists(filePath) {
+        try {
+            const zenfs = await this.getFs();
+            await zenfs.promises.access(filePath, zenfs.constants.F_OK);
+            return true;
+        }
+        catch (error) {
+            // ENOENT means the file doesn't exist, which is expected
+            if (error?.code === 'ENOENT' || error?.errno === -2) {
+                return false;
+            }
+            // For other errors, re-throw them
+            throw error;
+        }
+    }
+    static async createDirIfNotExists(filePath) {
+        if (!(await this.pathExists(filePath))) {
+            try {
+                const zenfs = await this.getFs();
+                await zenfs.promises.mkdir(filePath, { recursive: true });
+            }
+            catch (error) {
+                // This is a no-op. We tried to create a directory that already exists.
+                logger('Attempted to create a directory that already exists');
+            }
+        }
+    }
+    /**
+     * Waits for a file to exist at the specified path.
+     * @param {string} filePath - The path of the file to check.
+     * @param {number} interval - The interval in milliseconds between checks (default: 500ms).
+     * @param {number} timeout - The timeout in milliseconds to wait for the file to exist (default: 10s).
+     * @returns {Promise<boolean>} - Resolves to true if the file exists within the timeout period, otherwise false.
+     */
+    static async waitForFile(filePath, interval = 1000, timeout = 60000) {
+        // const fs = await this.getFs()
+        // const fsNode = await import('node:fs')
+        const pathExists = await this.pathExists(filePath);
+        if (pathExists) {
+            return true;
+        }
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            let isBusy = false;
+            const cancelableInterval = new CancelableInterval(async (stop) => {
+                logger('waitForFile', filePath);
+                if (isBusy) {
+                    return;
+                }
+                isBusy = true;
+                // // TODO: Needs to read from OPFS
+                // const exists = await BaseFileManager.pathExists(filePath)
+                // if (exists) {
+                //   stop()
+                //   resolve(true)
+                // }
+                const pathExists = await this.pathExists(filePath);
+                if (pathExists) {
+                    stop();
+                    resolve(true);
+                }
+                if (Date.now() - startTime >= timeout) {
+                    stop();
+                    reject(new Error('Timeout exceeded while waiting for file'));
+                }
+                isBusy = false;
+            }, interval);
+            cancelableInterval.start();
+            // const _interval = setInterval(async () => {
+            //   logger('waitForFile', filePath)
+            //   if (isBusy) {
+            //     return
+            //   }
+            //   isBusy = true
+            //   // TODO: Needs to read from OPFS
+            //   if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
+            //     clearInterval(_interval)
+            //     resolve(true)
+            //   }
+            //   const pathExists = await this.pathExists(filePath)
+            //   if (pathExists) {
+            //     clearInterval(_interval)
+            //     resolve(true)
+            //   }
+            //   if (Date.now() - startTime >= timeout) {
+            //     clearInterval(_interval)
+            //     reject(new Error('Timeout exceeded while waiting for file'))
+            //   }
+            //   isBusy = false
+            // }, interval)
+            // retry(
+            //   {
+            //     times: Math.ceil(timeout / interval),
+            //     interval: interval,
+            //   },
+            //   (callback: Function) => {
+            //     if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
+            //       return callback(null, true) // File exists, finish with success
+            //     }
+            //     if (Date.now() - startTime >= timeout) {
+            //       return callback(new Error('Timeout exceeded while waiting for file'))
+            //     }
+            //     callback(new Error('File does not exist yet')) // Retry with this error
+            //   },
+            //   (err: Error, result: boolean) => {
+            //     if (err) {
+            //       return resolve(false) // Resolve as false if timeout or error occurs
+            //     }
+            //     resolve(result) // Resolve as true if file exists
+            //   },
+            // )
+        });
+    }
+    /**
+     * Waits for a file to exist and have content (non-zero size).
+     * This is important for browser/OPFS where writes may not be immediately readable.
+     * @param {string} filePath - The path of the file to check.
+     * @param {number} interval - The interval in milliseconds between checks (default: 100ms).
+     * @param {number} timeout - The timeout in milliseconds to wait (default: 5s).
+     * @returns {Promise<boolean>} - Resolves to true if the file exists with content within the timeout period.
+     */
+    static async waitForFileWithContent(filePath, interval = 100, timeout = 5000) {
+        // First wait for file to exist
+        await this.waitForFile(filePath, interval, timeout);
+        // Now wait for file to have content
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            let isBusy = false;
+            const cancelableInterval = new CancelableInterval(async (stop) => {
+                logger('waitForFileWithContent', filePath);
+                if (isBusy) {
+                    return;
+                }
+                isBusy = true;
+                try {
+                    // Try to read the file to check if it has content
+                    const file = await this.readFile(filePath);
+                    if (file.size > 0) {
+                        stop();
+                        resolve(true);
+                        return;
+                    }
+                    // File exists but is 0 bytes, continue waiting
+                }
+                catch (error) {
+                    // If error is about file being 0 bytes, not readable, or I/O error, continue waiting
+                    const errorMessage = error?.message || String(error);
+                    if (errorMessage.includes('0 bytes') ||
+                        errorMessage.includes('ENOENT') ||
+                        errorMessage.includes('EIO') ||
+                        errorMessage.includes('Input/output error')) ;
+                    else {
+                        // Other errors should be thrown
+                        stop();
+                        reject(error);
+                        return;
+                    }
+                }
+                if (Date.now() - startTime >= timeout) {
+                    stop();
+                    reject(new Error(`Timeout exceeded while waiting for file ${filePath} to have content`));
+                    return;
+                }
+                isBusy = false;
+            }, interval);
+            cancelableInterval.start();
+        });
+    }
+    static async saveFile(filePath, content) {
+        const zenfs = await this.getFs();
+        // Convert content to a format that zenfs.writeFile accepts
+        let writeContent;
+        if (typeof content === 'string') {
+            writeContent = content;
+        }
+        else if (content instanceof Blob) {
+            const arrayBuffer = await content.arrayBuffer();
+            writeContent = new Uint8Array(arrayBuffer);
+        }
+        else if (content instanceof ArrayBuffer) {
+            writeContent = new Uint8Array(content);
+        }
+        else {
+            throw new Error('Unsupported content type');
+        }
+        await zenfs.writeFile(filePath, writeContent);
+        await this.waitForFileWithContent(filePath, 100, 5000);
+        // try {
+        //   // Get a handle to the OPFS root directory
+        //   const root = await navigator.storage.getDirectory();
+        //   // Split the file path into directory and file name
+        //   const pathParts = filePath.split('/');
+        //   const fileName = pathParts.pop();
+        //   if (!fileName) throw new Error('Invalid file path');
+        //   // Traverse directories and create them if they don't exist
+        //   let currentDir = root;
+        //   for (const part of pathParts) {
+        //     if (part !== '') {
+        //       currentDir = await currentDir.getDirectoryHandle(part, { create: true });
+        //     }
+        //   }
+        //   // Get the file handle and create the file if it doesn't exist
+        //   const fileHandle = await currentDir.getFileHandle(fileName, { create: true });
+        //   // Create a writable stream and write the content
+        //   const writable = await fileHandle.createWritable();
+        //   if (typeof content === 'string' || content instanceof Uint8Array) {
+        //       await writable.write(content);
+        //   } else if (content instanceof Blob) {
+        //       await writable.write(content);
+        //   } else if (content instanceof ArrayBuffer) {
+        //       await writable.write(new Blob([content]));
+        //   } else {
+        //       throw new Error('Unsupported content type');
+        //   }
+        //   await writable.close();
+        //   logger(`File written successfully: ${filePath}`);
+        // } catch (error) {
+        //     console.error(`Error writing to OPFS: ${error.message}`);
+        // }
+    }
+    static saveFileSync(filePath, content) {
+        // Note: This is a synchronous wrapper, but zenfs operations may still be async under the hood
+        // For true sync operations in browser, we'd need to use OPFS sync access handles
+        // For now, we'll use zenfs.writeFileSync which should be available
+        const zenfs = this.getFsSync();
+        // Convert content to a format that zenfs.writeFileSync accepts
+        let writeContent;
+        if (typeof content === 'string') {
+            writeContent = content;
+        }
+        else if (content instanceof Blob) {
+            // Blob cannot be converted synchronously - throw error
+            throw new Error('Blob content not supported in saveFileSync. Use saveFile() instead or convert to ArrayBuffer first.');
+        }
+        else if (content instanceof ArrayBuffer) {
+            writeContent = new Uint8Array(content);
+        }
+        else {
+            throw new Error('Unsupported content type');
+        }
+        zenfs.writeFileSync(filePath, writeContent);
+    }
+    static async readFile(filePath) {
+        const zenfs = await this.getFs();
+        const file = await zenfs.promises.readFile(filePath);
+        return new File([new Uint8Array(file)], filePath);
+        // try {
+        //   // Get a handle to the OPFS root directory
+        //   const root = await navigator.storage.getDirectory();
+        //    // Split the file path into directory and file name
+        //    const pathParts = filePath.split('/');
+        //    const fileName = pathParts.pop();
+        //    if (!fileName) throw new Error('Invalid file path');
+        //    // Traverse directories to reach the target file
+        //    let currentDir = root;
+        //    for (const part of pathParts) {
+        //      if (part !== '') {
+        //        currentDir = await currentDir.getDirectoryHandle(part, { create: false });
+        //      }
+        //    }
+        //    // Get the file handle
+        //    const fileHandle = await currentDir.getFileHandle(fileName, { create: false });
+        //    // Get the file and read it as an ArrayBuffer
+        //    return await fileHandle.getFile();
+        // } catch (error) {
+        //   console.error(`Error reading from OPFS: ${error.message}`);
+        //   throw error;
+        // }
+    }
+    static readFileSync(filePath) {
+        // Note: This is a synchronous wrapper, but zenfs operations may still be async under the hood
+        // For true sync operations in browser, we'd need to use OPFS sync access handles
+        // For now, we'll use zenfs.readFileSync which should be available
+        const zenfs = this.getFsSync();
+        const file = zenfs.readFileSync(filePath);
+        return new File([new Uint8Array(file)], filePath);
+    }
+    static async readFileAsBuffer(filePath) {
+        try {
+            // Get the file and read it as an ArrayBuffer
+            const file = await this.readFile(filePath);
+            const arrayBuffer = await file.arrayBuffer();
+            // Convert ArrayBuffer to Blob
+            return new Blob([arrayBuffer]);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error reading from OPFS: ${errorMessage}`);
+            throw error;
+        }
+    }
+    static async readFileAsString(filePath) {
+        const blob = await this.readFileAsBuffer(filePath);
+        return blob.text();
+    }
+    static getParentDirPath(filePath) {
+        return path.dirname(filePath);
+    }
+    static getFilenameFromPath(filePath) {
+        return path.basename(filePath);
+    }
+    static getPathModule() {
+        return path;
+    }
+}
+FileManager.zenfsCache = null;
+class CancelableInterval {
+    constructor(task, interval) {
+        this.task = task;
+        this.interval = interval;
+        this.intervalId = null;
+        this.currentTaskAbortController = null;
+    }
+    start() {
+        this.intervalId = window.setInterval(async () => {
+            if (this.currentTaskAbortController) {
+                // Cancel the previous running task
+                this.currentTaskAbortController.abort();
+            }
+            // Create a new abort controller for the current task
+            this.currentTaskAbortController = new AbortController();
+            const signal = this.currentTaskAbortController.signal;
+            try {
+                await this.taskWithCancellation(signal);
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    logger('Previous task was canceled.');
+                }
+                else {
+                    console.error('Task error:', error);
+                }
+                this.stop();
+            }
+        }, this.interval);
+    }
+    async taskWithCancellation(signal) {
+        await this.task(() => this.stop());
+        if (signal.aborted) {
+            throw new DOMException('Task was aborted', 'AbortError');
+        }
+    }
+    stop() {
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        if (this.currentTaskAbortController) {
+            this.currentTaskAbortController.abort();
+        }
+    }
+}
+
+export { FileManager };
+//# sourceMappingURL=FileManager-Wthr5yHO.js.map