opfs-worker 0.2.6 → 0.3.1

package/dist/{helpers-C0nyU6hv.js → helpers-DxFcNkZe.js}

@@ -1,44 +1,44 @@
-class o extends Error {
+class s extends Error {
   constructor(r, t, n) {
     super(r), this.code = t, this.path = n, this.name = "OPFSError";
   }
 }
-class l extends o {
+class l extends s {
   constructor() {
     super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
   }
 }
-class A extends o {
+class p extends s {
   constructor() {
     super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
   }
 }
-class m extends o {
+class S extends s {
   constructor(r, t) {
     super(r, "INVALID_PATH", t);
   }
 }
-class S extends o {
+class E extends s {
   constructor(r) {
     super(`File not found: ${r}`, "FILE_NOT_FOUND", r);
   }
 }
-class E extends o {
+class O extends s {
   constructor(r) {
     super(`Directory not found: ${r}`, "DIRECTORY_NOT_FOUND", r);
   }
 }
-class O extends o {
+class F extends s {
   constructor(r, t) {
     super(`Permission denied for ${t} on: ${r}`, "PERMISSION_DENIED", r);
   }
 }
-class F extends o {
+class U extends s {
   constructor(r, t) {
     super(r, "STORAGE_ERROR", t);
   }
 }
-class U extends o {
+class P extends s {
   constructor(r, t) {
     super(`Operation timed out: ${r}`, "TIMEOUT_ERROR", t);
   }
@@ -62,7 +62,7 @@ function f(e, r = "utf-8") {
       return Uint8Array.from(atob(e), (t) => t.charCodeAt(0));
     case "hex":
       if (!/^[\da-f]+$/i.test(e) || e.length % 2 !== 0)
-        throw new o("Invalid hex string", "INVALID_HEX_FORMAT");
+        throw new s("Invalid hex string", "INVALID_HEX_FORMAT");
       return Uint8Array.from(e.match(/.{1,2}/g).map((t) => parseInt(t, 16)));
     default:
       return console.warn("Encoding not supported, falling back to UTF-8"), new TextEncoder().encode(e);
@@ -121,39 +121,39 @@ function x() {
     throw new l();
 }
 function i(e) {
-  return Array.isArray(e) ? e : e.split("/").filter(Boolean);
+  return Array.isArray(e) ? e : (e.startsWith("~/") ? e.slice(2) : e).split("/").filter(Boolean);
 }
 function u(e) {
   return typeof e == "string" ? e ?? "/" : `/${e.join("/")}`;
 }
-function p(e) {
+function w(e) {
   const r = i(e);
   return r[r.length - 1] || "";
 }
-function P(e) {
+function D(e) {
   const r = i(e);
   return r.pop(), u(r);
 }
-function D(e) {
-  return !e || e === "/" ? "/" : e.startsWith("/") ? e : `/${e}`;
+function m(e) {
+  return !e || e === "/" ? "/" : e.startsWith("~/") ? `/${e.slice(2)}` : e.startsWith("/") ? e : `/${e}`;
 }
 function C(e) {
-  const r = i(e), t = [];
-  for (const n of r)
-    if (!(n === "." || n === ""))
-      if (n === "..") {
-        if (t.length === 0)
+  const r = m(e), t = i(r), n = [];
+  for (const o of t)
+    if (!(o === "." || o === ""))
+      if (o === "..") {
+        if (n.length === 0)
           continue;
-        t.pop();
+        n.pop();
       } else
-        t.push(n);
-  return u(t);
+        n.push(o);
+  return u(n);
 }
 function I(e) {
-  const r = p(e), t = r.lastIndexOf(".");
+  const r = w(e), t = r.lastIndexOf(".");
   return t <= 0 || t === r.length - 1 ? "" : r.slice(t);
 }
-function w(e, r = "utf-8") {
+function A(e, r = "utf-8") {
   return typeof e == "string" ? f(e, r) : e instanceof Uint8Array ? e : new Uint8Array(e);
 }
 async function N(e) {
@@ -166,57 +166,57 @@ async function N(e) {
   }
 }
 async function _(e, r, t, n = {}) {
-  let s = null;
+  let o = null;
   try {
-    s = await e.createSyncAccessHandle();
-    const a = w(r, t), c = n.append ? s.getSize() : 0;
-    s.write(a, { at: c }), n.truncate && !n.append && s.truncate(a.byteLength), s.flush();
+    o = await e.createSyncAccessHandle();
+    const a = A(r, t), c = n.append ? o.getSize() : 0;
+    o.write(a, { at: c }), n.truncate && !n.append && o.truncate(a.byteLength), o.flush();
   } catch (a) {
     console.error(a);
     const c = n.append ? "append" : "write";
-    throw new o(`Failed to ${c} file`, `${c.toUpperCase()}_FAILED`);
+    throw new s(`Failed to ${c} file`, `${c.toUpperCase()}_FAILED`);
   } finally {
-    if (s)
+    if (o)
       try {
-        s.close();
+        o.close();
       } catch {
       }
   }
 }
-async function L(e, r = "SHA-1", t = 50 * 1024 * 1024) {
+async function $(e, r = "SHA-1", t = 50 * 1024 * 1024) {
   if (e instanceof File && (e = await e.arrayBuffer()), e.byteLength > t)
     throw new Error(`File size ${e.byteLength} bytes exceeds maximum allowed size ${t} bytes`);
-  const n = new Uint8Array(e), s = await crypto.subtle.digest(r, n);
-  return Array.from(new Uint8Array(s)).map((c) => c.toString(16).padStart(2, "0")).join("");
+  const n = new Uint8Array(e), o = await crypto.subtle.digest(r, n);
+  return Array.from(new Uint8Array(o)).map((c) => c.toString(16).padStart(2, "0")).join("");
 }
-async function R(e) {
+async function L(e) {
   const r = await e.arrayBuffer();
   return new Uint8Array(r);
 }
 export {
-  E as D,
-  S as F,
-  o as O,
-  m as P,
-  F as S,
-  U as T,
+  O as D,
+  E as F,
+  s as O,
+  S as P,
+  U as S,
+  P as T,
   l as a,
-  A as b,
-  O as c,
+  p as b,
+  F as c,
   x as d,
-  p as e,
-  P as f,
+  w as e,
+  D as f,
   I as g,
-  w as h,
+  A as h,
   N as i,
   u as j,
-  L as k,
-  R as l,
+  $ as k,
+  L as l,
   f as m,
-  D as n,
+  m as n,
   T as o,
   C as r,
   i as s,
   _ as w
 };
-//# sourceMappingURL=helpers-C0nyU6hv.js.map
+//# sourceMappingURL=helpers-DxFcNkZe.js.map

package/dist/helpers-DxFcNkZe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers-DxFcNkZe.js","sources":["../src/utils/errors.ts","../src/utils/encoder.ts","../src/utils/helpers.ts"],"sourcesContent":["/**\n * Base error class for all OPFS-related errors\n */\nexport class OPFSError extends Error {\n    constructor(message: string, public readonly code: string, public readonly path?: string) {\n        super(message);\n        this.name = 'OPFSError';\n    }\n}\n\n/**\n * Error thrown when OPFS is not supported in the current browser\n */\nexport class OPFSNotSupportedError extends OPFSError {\n    constructor() {\n        super('OPFS is not supported in this browser', 'OPFS_NOT_SUPPORTED');\n    }\n}\n\n\n/**\n * Error thrown when OPFS is not mounted\n */\nexport class OPFSNotMountedError extends OPFSError {\n    constructor() {\n        super('OPFS is not mounted', 'OPFS_NOT_MOUNTED');\n    }\n}\n\n/**\n * Error thrown for invalid paths or path traversal attempts\n */\nexport class PathError extends OPFSError {\n    constructor(message: string, path: string) {\n        super(message, 'INVALID_PATH', path);\n    }\n}\n\n/**\n * Error thrown when a requested file doesn't exist\n */\nexport class FileNotFoundError extends OPFSError {\n    constructor(path: string) {\n        super(`File not found: ${ path }`, 'FILE_NOT_FOUND', path);\n    }\n}\n\n/**\n * Error thrown when a requested directory doesn't exist\n */\nexport class DirectoryNotFoundError extends OPFSError {\n    constructor(path: string) {\n        super(`Directory not found: ${ path }`, 'DIRECTORY_NOT_FOUND', path);\n    }\n}\n\n/**\n * Error thrown when permission is denied for an operation\n */\nexport class PermissionError extends OPFSError {\n    constructor(path: string, operation: string) {\n        super(`Permission denied for ${ operation } on: ${ path }`, 'PERMISSION_DENIED', path);\n    }\n}\n\n/**\n * Error thrown when an operation fails due to insufficient storage\n */\nexport class StorageError extends OPFSError {\n    constructor(message: string, path?: string) {\n        super(message, 'STORAGE_ERROR', path);\n    }\n}\n\n/**\n * Error thrown when an operation times out\n */\nexport class TimeoutError extends OPFSError {\n    constructor(operation: string, path?: string) {\n        super(`Operation timed out: ${ operation }`, 'TIMEOUT_ERROR', path);\n    }\n}\n","import { OPFSError } from './errors';\n\nimport type { BufferEncoding } from 'typescript';\n\nexport function encodeString(data: string, encoding: BufferEncoding = 'utf-8'): Uint8Array {\n    switch (encoding) {\n        case 'utf8':\n        case 'utf-8':\n            return new TextEncoder().encode(data);\n\n        case 'utf16le':\n        case 'ucs2':\n        case 'ucs-2':\n            return encodeUtf16LE(data);\n\n        case 'ascii':\n            return encodeAscii(data);\n\n        case 'latin1':\n            return encodeLatin1(data);\n\n        case 'binary':\n            return Uint8Array.from(data, char => char.charCodeAt(0));\n\n        case 'base64':\n            return Uint8Array.from(atob(data), c => c.charCodeAt(0));\n\n        case 'hex':\n            if (!/^[\\da-f]+$/i.test(data) || data.length % 2 !== 0) {\n                throw new OPFSError('Invalid hex string', 'INVALID_HEX_FORMAT');\n            }\n\n            return Uint8Array.from(data.match(/.{1,2}/g)!.map(b => parseInt(b, 16)));\n\n        default:\n            console.warn('Encoding not supported, falling back to UTF-8');\n\n            return new TextEncoder().encode(data);\n    }\n}\n\nexport function decodeBuffer(buffer: Uint8Array, encoding: BufferEncoding = 'utf-8'): string {\n    switch (encoding) {\n        case 'utf8':\n        case 'utf-8':\n            return new TextDecoder().decode(buffer);\n\n        case 'utf16le':\n        case 'ucs2':\n        case 'ucs-2':\n            return decodeUtf16LE(buffer);\n\n        case 'latin1':\n            return String.fromCharCode(...buffer);\n\n        case 'binary':\n            return String.fromCharCode(...buffer);\n\n        case 'ascii':\n            return String.fromCharCode(...buffer.map(b => b & 0x7F));\n\n        case 'base64':\n            return btoa(String.fromCharCode(...buffer));\n\n        case 'hex':\n            return Array.from(buffer).map(b => b.toString(16).padStart(2, '0')).join('');\n\n        default:\n            console.warn('Unsupported encoding, falling back to UTF-8');\n\n            return new TextDecoder().decode(buffer);\n    }\n}\n\nfunction encodeUtf16LE(str: string): Uint8Array {\n    const buf = new Uint8Array(str.length * 2);\n\n    for (let i = 0; i < str.length; i++) {\n        const code = str.charCodeAt(i);\n\n        buf[(i * 2)] = code & 0xFF;\n        buf[(i * 2) + 1] = code >> 8;\n    }\n\n    return buf;\n}\n\nfunction decodeUtf16LE(buf: Uint8Array): string {\n    if (buf.length % 2 !== 0) {\n        console.warn('Invalid UTF-16LE buffer length, truncating last byte');\n        buf = buf.slice(0, buf.length - 1);\n    }\n\n    const codeUnits = new Uint16Array(buf.buffer, buf.byteOffset, buf.byteLength / 2);\n\n    return String.fromCharCode(...codeUnits);\n}\n\nfunction encodeLatin1(str: string): Uint8Array {\n    const buf = new Uint8Array(str.length);\n\n    for (let i = 0; i < str.length; i++) {\n        buf[i] = str.charCodeAt(i) & 0xFF;\n    }\n\n    return buf;\n}\n\nfunction encodeAscii(str: string): Uint8Array {\n    const buf = new Uint8Array(str.length);\n\n    for (let i = 0; i < str.length; i++) {\n        buf[i] = str.charCodeAt(i) & 0x7F;\n    }\n\n    return buf;\n}\n","import { encodeString } from './encoder';\nimport { OPFSError, OPFSNotSupportedError } from './errors';\n\nimport type { BufferEncoding } from 'typescript';\n\n/**\n * Check if the browser supports the OPFS API\n * \n * @throws {OPFSNotSupportedError} If the browser does not support the OPFS API\n */\nexport function checkOPFSSupport(): void {\n    if (!('storage' in navigator) || !('getDirectory' in (navigator.storage as any))) {\n        throw new OPFSNotSupportedError();\n    }\n}\n\n/** \n * Split a path into an array of segments\n * \n * @param path - The path to split\n * @returns The array of segments\n * \n * @example\n * ```typescript\n * splitPath('/path/to/file'); // ['path', 'to', 'file']\n * splitPath('~/path/to/file'); // ['path', 'to', 'file'] (home dir handled)\n * splitPath('relative/path'); // ['relative', 'path']\n * ```\n */\nexport function splitPath(path: string | string[]): string[] {\n    if (Array.isArray(path)) {\n        return path;\n    }\n\n    const normalizedPath = path.startsWith('~/') ? path.slice(2) : path;\n\n    return normalizedPath.split('/').filter(Boolean);\n}\n\n\n/**\n * Join an array of path segments into a single path\n * \n * @param segments - The array of path segments\n * @returns The joined path\n */\nexport function joinPath(segments: string[] | string): string {\n    return typeof segments === 'string'\n        ? (segments ?? '/')\n        : `/${ segments.join('/') }`;\n}\n\n/**\n * Extract the filename from a path\n * \n * @param path - The file path\n * @returns The filename without the directory path\n * \n * @example\n * ```typescript\n * basename('/path/to/file.txt'); // 'file.txt'\n * basename('/path/to/directory/'); // ''\n * basename('file.txt'); // 'file.txt'\n * ```\n */\nexport function basename(path: string): string {\n    const segments = splitPath(path);\n    return segments[segments.length - 1] || '';\n}\n\n/**\n * Extract the directory path from a file path\n * \n * @param path - The file path\n * @returns The directory path without the filename\n * \n * @example\n * ```typescript\n * dirname('/path/to/file.txt'); // '/path/to'\n * dirname('/path/to/directory/'); // '/path/to/directory'\n * dirname('file.txt'); // '/'\n * ```\n */\nexport function dirname(path: string): string {\n    const segments = splitPath(path);\n    segments.pop();\n    return joinPath(segments);\n}\n\n/**\n * Normalize a path to ensure it starts with '/'\n * \n * @param path - The path to normalize\n * @returns The normalized path\n * \n * @example\n * ```typescript\n * normalizePath('path/to/file'); // '/path/to/file'\n * normalizePath('/path/to/file'); // '/path/to/file'\n * normalizePath('~/path/to/file'); // '/path/to/file' (home dir normalized to root)\n * normalizePath(''); // '/'\n * ```\n */\nexport function normalizePath(path: string): string {\n    if (!path || path === '/') {\n        return '/';\n    }\n    \n    if (path.startsWith('~/')) {\n        return `/${path.slice(2)}`;\n    }\n    \n    return path.startsWith('/') ? path : `/${path}`;\n}\n\n/**\n * Resolve a path to an absolute path, handling relative segments\n * \n * @param path - The path to resolve\n * @returns The resolved absolute path\n * \n * @example\n * ```typescript\n * resolvePath('./config/../data/file.txt'); // '/data/file.txt'\n * resolvePath('/path/to/../file.txt'); // '/path/file.txt'\n * resolvePath('../../file.txt'); // '/file.txt' (truncated to root)\n * resolvePath('~/config/../data/file.txt'); // '/data/file.txt' (home dir normalized to root)\n * ```\n */\nexport function resolvePath(path: string): string {\n    // First normalize the path to handle home directory references\n    const normalizedPath = normalizePath(path);\n    const segments = splitPath(normalizedPath);\n    const normalizedSegments: string[] = [];\n\n    for (const segment of segments) {\n        if (segment === '.' || segment === '') {\n            // Skip current directory references and empty segments\n            continue;\n        }\n        else if (segment === '..') {\n            if (normalizedSegments.length === 0) {\n                // Path escapes root, keep at root level\n                continue;\n            }\n            // Go up one directory\n            normalizedSegments.pop();\n        }\n        else {\n            normalizedSegments.push(segment);\n        }\n    }\n\n    return joinPath(normalizedSegments);\n}\n\n/**\n * Get the file extension from a path\n * \n * @param path - The file path\n * @returns The file extension including the dot, or empty string if no extension\n * \n * @example\n * ```typescript\n * extname('/path/to/file.txt'); // '.txt'\n * extname('/path/to/file'); // ''\n * extname('/path/to/file.name.ext'); // '.ext'\n * extname('/path/to/.hidden'); // ''\n * ```\n */\nexport function extname(path: string): string {\n    const filename = basename(path);\n    const lastDotIndex = filename.lastIndexOf('.');\n    \n    if (lastDotIndex <= 0 || lastDotIndex === filename.length - 1) {\n        return '';\n    }\n    \n    return filename.slice(lastDotIndex);\n}\n\nexport function createBuffer(data: string | Uint8Array | ArrayBuffer, encoding: BufferEncoding = 'utf-8'): Uint8Array {\n    if (typeof data === 'string') {\n        return encodeString(data, encoding);\n    }\n\n    return data instanceof Uint8Array ? data : new Uint8Array(data);\n}\n\n\n/**\n * Read raw binary data from a file using a file handle\n *\n * @param fileHandle - The file handle to read from\n * @returns The raw binary data as Uint8Array\n */\nexport async function readFileData(fileHandle: FileSystemFileHandle): Promise<Uint8Array> {\n    const handle = await fileHandle.createSyncAccessHandle();\n\n    try {\n        const size = handle.getSize();\n        const buffer = new Uint8Array(size);\n\n        handle.read(buffer, { at: 0 });\n\n        return buffer;\n    }\n    finally {\n        handle.close();\n    }\n}\n\n/**\n * Write data to a file using a file handle\n *\n * @param fileHandle - The file handle to write to\n * @param data - The data to write to the file\n * @param encoding - The encoding to use\n * @param options - Write options (truncate or append)\n */\nexport async function writeFileData(\n    fileHandle: FileSystemFileHandle,\n    data: string | Uint8Array | ArrayBuffer,\n    encoding?: BufferEncoding,\n    options: { truncate?: boolean; append?: boolean } = {}\n): Promise<void> {\n    let handle: FileSystemSyncAccessHandle | null = null;\n\n    try {\n        handle = await fileHandle.createSyncAccessHandle();\n\n        const buffer = createBuffer(data, encoding);\n        const writeOffset = options.append ? handle.getSize() : 0;\n\n        handle.write(buffer, { at: writeOffset });\n\n        if (options.truncate && !options.append) {\n            handle.truncate(buffer.byteLength);\n        }\n\n        handle.flush();\n    }\n    catch (error) {\n        console.error(error);\n        const operation = options.append ? 'append' : 'write';\n\n        throw new OPFSError(`Failed to ${ operation } file`, `${ operation.toUpperCase() }_FAILED`);\n    }\n    finally {\n        if (handle) {\n            try {\n                handle.close();\n            }\n            catch { /* ~ */ }\n        }\n    }\n}\n\n/**\n * Calculate file hash using Web Crypto API\n * \n * @param buffer - The file content as File, ArrayBuffer, or Uint8Array\n * @param algorithm - Hash algorithm to use (default: 'SHA-1')\n * @param maxSize - Maximum file size in bytes. If file is larger, throws error (default: 50MB)\n * @returns Promise that resolves to the hash string\n * @throws Error if file size exceeds maxSize\n */\nexport async function calculateFileHash(\n    buffer: File | ArrayBuffer | Uint8Array, \n    algorithm: string = 'SHA-1',\n    maxSize: number = 50 * 1024 * 1024 // 50MB default\n): Promise<string> {\n    if (buffer instanceof File) {\n        buffer = await buffer.arrayBuffer();\n    }\n    \n    // Check file size before processing\n    if (buffer.byteLength > maxSize) {\n        throw new Error(`File size ${buffer.byteLength} bytes exceeds maximum allowed size ${maxSize} bytes`);\n    }\n\n    const bufferSource = new Uint8Array(buffer);\n    const hashBuffer = await crypto.subtle.digest(algorithm, bufferSource);\n    const hashArray = Array.from(new Uint8Array(hashBuffer));\n\n    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n}\n\n/**\n * Convert a Blob to Uint8Array\n * \n * This function converts a Blob object to a Uint8Array for use with file operations.\n * It's useful when working with file uploads or other Blob data sources.\n * \n * @param blob - The Blob to convert\n * @returns Promise that resolves to the Uint8Array representation of the Blob\n * \n * @example\n * ```typescript\n * const fileInput = document.getElementById('file') as HTMLInputElement;\n * const file = fileInput.files?.[0];\n * if (file) {\n *   const data = await convertBlobToUint8Array(file);\n *   await fs.writeFile('/uploaded-file', data);\n * }\n * ```\n */\nexport async function convertBlobToUint8Array(blob: Blob): Promise<Uint8Array> {\n    const arrayBuffer = await blob.arrayBuffer();\n    return new Uint8Array(arrayBuffer);\n}\n"],"names":["OPFSError","message","code","path","OPFSNotSupportedError","OPFSNotMountedError","PathError","FileNotFoundError","DirectoryNotFoundError","PermissionError","operation","StorageError","TimeoutError","encodeString","data","encoding","encodeUtf16LE","encodeAscii","encodeLatin1","char","c","b","decodeBuffer","buffer","decodeUtf16LE","str","buf","i","codeUnits","checkOPFSSupport","splitPath","joinPath","segments","basename","dirname","normalizePath","resolvePath","normalizedPath","normalizedSegments","segment","extname","filename","lastDotIndex","createBuffer","readFileData","fileHandle","handle","size","writeFileData","options","writeOffset","error","calculateFileHash","algorithm","maxSize","bufferSource","hashBuffer","convertBlobToUint8Array","blob","arrayBuffer"],"mappings":"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"}