opfs-worker 0.2.1 → 0.2.2

package/dist/utils/encoder.js

@@ -1,83 +0,0 @@
-import { OPFSError } from './errors';
-export function encodeString(data, encoding = 'utf-8') {
-    switch (encoding) {
-        case 'utf8':
-        case 'utf-8':
-            return new TextEncoder().encode(data);
-        case 'utf16le':
-        case 'ucs2':
-        case 'ucs-2':
-            return encodeUtf16LE(data);
-        case 'ascii':
-            return encodeAscii(data);
-        case 'latin1':
-            return encodeLatin1(data);
-        case 'binary':
-            return Uint8Array.from(data, char => char.charCodeAt(0));
-        case 'base64':
-            return Uint8Array.from(atob(data), c => c.charCodeAt(0));
-        case 'hex':
-            if (!/^[\da-f]+$/i.test(data) || data.length % 2 !== 0) {
-                throw new OPFSError('Invalid hex string', 'INVALID_HEX_FORMAT');
-            }
-            return Uint8Array.from(data.match(/.{1,2}/g).map(b => parseInt(b, 16)));
-        default:
-            console.warn('Encoding not supported, falling back to UTF-8');
-            return new TextEncoder().encode(data);
-    }
-}
-export function decodeBuffer(buffer, encoding = 'utf-8') {
-    switch (encoding) {
-        case 'utf8':
-        case 'utf-8':
-            return new TextDecoder().decode(buffer);
-        case 'utf16le':
-        case 'ucs2':
-        case 'ucs-2':
-            return decodeUtf16LE(buffer);
-        case 'latin1':
-            return String.fromCharCode(...buffer);
-        case 'binary':
-            return String.fromCharCode(...buffer);
-        case 'ascii':
-            return String.fromCharCode(...buffer.map(b => b & 0x7F));
-        case 'base64':
-            return btoa(String.fromCharCode(...buffer));
-        case 'hex':
-            return Array.from(buffer).map(b => b.toString(16).padStart(2, '0')).join('');
-        default:
-            console.warn('Unsupported encoding, falling back to UTF-8');
-            return new TextDecoder().decode(buffer);
-    }
-}
-function encodeUtf16LE(str) {
-    const buf = new Uint8Array(str.length * 2);
-    for (let i = 0; i < str.length; i++) {
-        const code = str.charCodeAt(i);
-        buf[(i * 2)] = code & 0xFF;
-        buf[(i * 2) + 1] = code >> 8;
-    }
-    return buf;
-}
-function decodeUtf16LE(buf) {
-    if (buf.length % 2 !== 0) {
-        console.warn('Invalid UTF-16LE buffer length, truncating last byte');
-        buf = buf.slice(0, buf.length - 1);
-    }
-    const codeUnits = new Uint16Array(buf.buffer, buf.byteOffset, buf.byteLength / 2);
-    return String.fromCharCode(...codeUnits);
-}
-function encodeLatin1(str) {
-    const buf = new Uint8Array(str.length);
-    for (let i = 0; i < str.length; i++) {
-        buf[i] = str.charCodeAt(i) & 0xFF;
-    }
-    return buf;
-}
-function encodeAscii(str) {
-    const buf = new Uint8Array(str.length);
-    for (let i = 0; i < str.length; i++) {
-        buf[i] = str.charCodeAt(i) & 0x7F;
-    }
-    return buf;
-}

package/dist/utils/errors.js

@@ -1,77 +0,0 @@
-/**
- * Base error class for all OPFS-related errors
- */
-export class OPFSError extends Error {
-    code;
-    path;
-    constructor(message, code, path) {
-        super(message);
-        this.code = code;
-        this.path = path;
-        this.name = 'OPFSError';
-    }
-}
-/**
- * Error thrown when OPFS is not supported in the current browser
- */
-export class OPFSNotSupportedError extends OPFSError {
-    constructor() {
-        super('OPFS is not supported in this browser', 'OPFS_NOT_SUPPORTED');
-    }
-}
-/**
- * Error thrown when OPFS is not mounted
- */
-export class OPFSNotMountedError extends OPFSError {
-    constructor() {
-        super('OPFS is not mounted', 'OPFS_NOT_MOUNTED');
-    }
-}
-/**
- * Error thrown for invalid paths or path traversal attempts
- */
-export class PathError extends OPFSError {
-    constructor(message, path) {
-        super(message, 'INVALID_PATH', path);
-    }
-}
-/**
- * Error thrown when a requested file doesn't exist
- */
-export class FileNotFoundError extends OPFSError {
-    constructor(path) {
-        super(`File not found: ${path}`, 'FILE_NOT_FOUND', path);
-    }
-}
-/**
- * Error thrown when a requested directory doesn't exist
- */
-export class DirectoryNotFoundError extends OPFSError {
-    constructor(path) {
-        super(`Directory not found: ${path}`, 'DIRECTORY_NOT_FOUND', path);
-    }
-}
-/**
- * Error thrown when permission is denied for an operation
- */
-export class PermissionError extends OPFSError {
-    constructor(path, operation) {
-        super(`Permission denied for ${operation} on: ${path}`, 'PERMISSION_DENIED', path);
-    }
-}
-/**
- * Error thrown when an operation fails due to insufficient storage
- */
-export class StorageError extends OPFSError {
-    constructor(message, path) {
-        super(message, 'STORAGE_ERROR', path);
-    }
-}
-/**
- * Error thrown when an operation times out
- */
-export class TimeoutError extends OPFSError {
-    constructor(operation, path) {
-        super(`Operation timed out: ${operation}`, 'TIMEOUT_ERROR', path);
-    }
-}

package/dist/utils/helpers.js

@@ -1,246 +0,0 @@
-import { encodeString } from './encoder';
-import { OPFSError, OPFSNotSupportedError } from './errors';
-/**
- * Check if the browser supports the OPFS API
- *
- * @throws {OPFSNotSupportedError} If the browser does not support the OPFS API
- */
-export function checkOPFSSupport() {
-    if (!('storage' in navigator) || !('getDirectory' in navigator.storage)) {
-        throw new OPFSNotSupportedError();
-    }
-}
-/**
- * Split a path into an array of segments
- *
- * @param path - The path to split
- * @returns The array of segments
- */
-export function splitPath(path) {
-    if (Array.isArray(path)) {
-        return path;
-    }
-    return path.split('/').filter(Boolean);
-}
-/**
- * Join an array of path segments into a single path
- *
- * @param segments - The array of path segments
- * @returns The joined path
- */
-export function joinPath(segments) {
-    return typeof segments === 'string'
-        ? (segments ?? '/')
-        : `/${segments.join('/')}`;
-}
-/**
- * Extract the filename from a path
- *
- * @param path - The file path
- * @returns The filename without the directory path
- *
- * @example
- * ```typescript
- * basename('/path/to/file.txt'); // 'file.txt'
- * basename('/path/to/directory/'); // ''
- * basename('file.txt'); // 'file.txt'
- * ```
- */
-export function basename(path) {
-    const segments = splitPath(path);
-    return segments[segments.length - 1] || '';
-}
-/**
- * Extract the directory path from a file path
- *
- * @param path - The file path
- * @returns The directory path without the filename
- *
- * @example
- * ```typescript
- * dirname('/path/to/file.txt'); // '/path/to'
- * dirname('/path/to/directory/'); // '/path/to/directory'
- * dirname('file.txt'); // '/'
- * ```
- */
-export function dirname(path) {
-    const segments = splitPath(path);
-    segments.pop();
-    return joinPath(segments);
-}
-/**
- * Normalize a path to ensure it starts with '/'
- *
- * @param path - The path to normalize
- * @returns The normalized path
- *
- * @example
- * ```typescript
- * normalizePath('path/to/file'); // '/path/to/file'
- * normalizePath('/path/to/file'); // '/path/to/file'
- * normalizePath(''); // '/'
- * ```
- */
-export function normalizePath(path) {
-    if (!path || path === '/') {
-        return '/';
-    }
-    return path.startsWith('/') ? path : `/${path}`;
-}
-/**
- * Resolve a path to an absolute path, handling relative segments
- *
- * @param path - The path to resolve
- * @returns The resolved absolute path
- *
- * @example
- * ```typescript
- * resolvePath('./config/../data/file.txt'); // '/data/file.txt'
- * resolvePath('/path/to/../file.txt'); // '/path/file.txt'
- * resolvePath('../../file.txt'); // '/file.txt' (truncated to root)
- * ```
- */
-export function resolvePath(path) {
-    const segments = splitPath(path);
-    const normalizedSegments = [];
-    for (const segment of segments) {
-        if (segment === '.' || segment === '') {
-            // Skip current directory references and empty segments
-            continue;
-        }
-        else if (segment === '..') {
-            if (normalizedSegments.length === 0) {
-                // Path escapes root, keep at root level
-                continue;
-            }
-            // Go up one directory
-            normalizedSegments.pop();
-        }
-        else {
-            normalizedSegments.push(segment);
-        }
-    }
-    return joinPath(normalizedSegments);
-}
-/**
- * Get the file extension from a path
- *
- * @param path - The file path
- * @returns The file extension including the dot, or empty string if no extension
- *
- * @example
- * ```typescript
- * extname('/path/to/file.txt'); // '.txt'
- * extname('/path/to/file'); // ''
- * extname('/path/to/file.name.ext'); // '.ext'
- * extname('/path/to/.hidden'); // ''
- * ```
- */
-export function extname(path) {
-    const filename = basename(path);
-    const lastDotIndex = filename.lastIndexOf('.');
-    if (lastDotIndex <= 0 || lastDotIndex === filename.length - 1) {
-        return '';
-    }
-    return filename.slice(lastDotIndex);
-}
-export function createBuffer(data, encoding = 'utf-8') {
-    if (typeof data === 'string') {
-        return encodeString(data, encoding);
-    }
-    return data instanceof Uint8Array ? data : new Uint8Array(data);
-}
-/**
- * Read raw binary data from a file using a file handle
- *
- * @param fileHandle - The file handle to read from
- * @returns The raw binary data as Uint8Array
- */
-export async function readFileData(fileHandle) {
-    const handle = await fileHandle.createSyncAccessHandle();
-    try {
-        const size = handle.getSize();
-        const buffer = new Uint8Array(size);
-        handle.read(buffer, { at: 0 });
-        return buffer;
-    }
-    finally {
-        handle.close();
-    }
-}
-/**
- * Write data to a file using a file handle
- *
- * @param fileHandle - The file handle to write to
- * @param data - The data to write to the file
- * @param encoding - The encoding to use
- * @param options - Write options (truncate or append)
- */
-export async function writeFileData(fileHandle, data, encoding, options = {}) {
-    let handle = null;
-    try {
-        handle = await fileHandle.createSyncAccessHandle();
-        const buffer = createBuffer(data, encoding);
-        const writeOffset = options.append ? handle.getSize() : 0;
-        handle.write(buffer, { at: writeOffset });
-        if (options.truncate && !options.append) {
-            handle.truncate(buffer.byteLength);
-        }
-        handle.flush();
-    }
-    catch (error) {
-        console.error(error);
-        const operation = options.append ? 'append' : 'write';
-        throw new OPFSError(`Failed to ${operation} file`, `${operation.toUpperCase()}_FAILED`);
-    }
-    finally {
-        if (handle) {
-            try {
-                handle.close();
-            }
-            catch { /* ~ */ }
-        }
-    }
-}
-/**
- * Calculate file hash using Web Crypto API
- *
- * @param buffer - The file content as Uint8Array
- * @param algorithm - Hash algorithm to use (default: 'SHA-1')
- * @returns Promise that resolves to the hash string
- */
-export async function calculateFileHash(buffer, algorithm = 'SHA-1') {
-    try {
-        const bufferSource = new Uint8Array(buffer);
-        const hashBuffer = await crypto.subtle.digest(algorithm, bufferSource);
-        const hashArray = Array.from(new Uint8Array(hashBuffer));
-        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-    }
-    catch (error) {
-        console.warn(`Failed to calculate ${algorithm} hash:`, error);
-        throw error;
-    }
-}
-/**
- * Convert a Blob to Uint8Array
- *
- * This function converts a Blob object to a Uint8Array for use with file operations.
- * It's useful when working with file uploads or other Blob data sources.
- *
- * @param blob - The Blob to convert
- * @returns Promise that resolves to the Uint8Array representation of the Blob
- *
- * @example
- * ```typescript
- * const fileInput = document.getElementById('file') as HTMLInputElement;
- * const file = fileInput.files?.[0];
- * if (file) {
- *   const data = await convertBlobToUint8Array(file);
- *   await fs.writeFile('/uploaded-file', data);
- * }
- * ```
- */
-export async function convertBlobToUint8Array(blob) {
-    const arrayBuffer = await blob.arrayBuffer();
-    return new Uint8Array(arrayBuffer);
-}