@mad-c/file-system-helpers 1.0.0

package/dist/opfs.d.ts

@@ -0,0 +1,247 @@
+export interface GetDirHandleOptions {
+    /** Creates the directory structure if it doesn't exist. Throws an error otherwise */
+    recursive?: boolean;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Gets the directory handle for a given path.
+ *
+ * @param path The path to get a directory handle.
+ * @param options The options for function.
+ */
+export declare function getDirHandle(path: string, { rootDir, recursive }?: GetDirHandleOptions): Promise<FileSystemDirectoryHandle>;
+/**
+ * Resolves the parent item for this path or handle.
+ *
+ * If the root of the file system is passed, it returns the root itself.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param options The options for function.
+ */
+export declare function resolveParentHandle(pathOrHandle: string | FileSystemHandle, { recursive, rootDir }?: GetDirHandleOptions): Promise<{
+    parentHandle: FileSystemDirectoryHandle;
+    parentPath: string;
+    name: string;
+}>;
+export interface GetFileHandleOptions {
+    /** Creates the file if it doesn't exist. Throws an error otherwise */
+    touch?: boolean;
+    /** Creates the directory structure if it doesn't exist. Throws an error otherwise */
+    recursive?: boolean;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Gets a file handle for a given path. Optionally creating the file if it doesn't exist.
+ *
+ * @param path A path string for the file.
+ * @param options The options for function.
+ */
+export declare function getFileHandle(path: string, { touch, recursive, rootDir }?: GetFileHandleOptions): Promise<FileSystemFileHandle>;
+export interface CheckDirExistsOptions {
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+export declare function checkDirExists(path: string, { rootDir }?: CheckDirExistsOptions): Promise<boolean>;
+export interface CheckFileExistsOptions {
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+export declare function checkFileExists(path: string, { rootDir }?: CheckFileExistsOptions): Promise<boolean>;
+export interface ListDirEntriesOptions {
+    /** The depth to recurse on the directory tree. It defaults to 0 */
+    depth?: number;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+export interface FileSystemEntry {
+    name: string;
+    handle: FileSystemHandle;
+    children?: FileSystemEntry[];
+}
+/**
+ * Lists the directory contents recursivelly up to the `depth` provided.
+ *
+ * It returns an array of items, if the item have children and the depth is not exceeded, the children property will be filled.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param options The options for function.
+ */
+export declare function listDirEntries(pathOrHandle: string | FileSystemDirectoryHandle, { depth, rootDir }?: ListDirEntriesOptions): Promise<FileSystemEntry[]>;
+export interface WriteFileHandleOptions {
+    /** Creates the directory structure if it doesn't exist. Throws an error otherwise */
+    recursive?: boolean;
+    /** Overwrites the file if it exists. */
+    overwrite?: boolean;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Write data to a file, overwriting existing data.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param data The data to write to the file.
+ * @param options The options for function.
+ */
+export declare function writeFile(pathOrHandle: string | FileSystemFileHandle, data: FileSystemWriteChunkType, { recursive, rootDir, overwrite }?: WriteFileHandleOptions): Promise<void>;
+export interface AppendFileHandleOptions {
+    /** Creates the directory structure if it doesn't exist. Throws an error otherwise */
+    recursive?: boolean;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Appends data to the end of a file.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param data The data to append to the file.
+ * @param options The options for function.
+ */
+export declare function appendFile(pathOrHandle: string | FileSystemFileHandle, data: FileSystemWriteChunkType, { recursive, rootDir }?: AppendFileHandleOptions): Promise<void>;
+export interface RemoveDirOptions {
+    /**
+     * If the directory has children and this is set to `true`, removes the children.
+     * If it is set to `false` and the directory has children, throws an error.
+     * If the directory has no children, this has no effect.
+     */
+    recursive?: boolean;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Deletes a directory, optionally also deleting it's contents recursivelly.
+ *
+ * If the directory is the root of the file system, all children will be deleted but the root directory itself will be kept.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param options The options for function.
+ */
+export declare function removeDir(pathOrHandle: string | FileSystemDirectoryHandle, { recursive, rootDir }: RemoveDirOptions): Promise<void>;
+export interface RemoveFileOptions {
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Deletes a file.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param options The options for function.
+ */
+export declare function removeFile(pathOrHandle: string | FileSystemFileHandle, { rootDir }?: RemoveFileOptions): Promise<void>;
+export interface CopyDirOptions {
+    /** Creates the destination directory structure if it doesn't exist. Throws an error otherwise */
+    recursive?: boolean;
+    /** Overwrites existing files in the destination. */
+    overwrite?: boolean;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Copies a directory from one location to another.
+ *
+ * @param sourcePathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the source directory.
+ * @param destinationPathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the destination directory.
+ * @param options The options for function.
+ */
+export declare function copyDir(sourcePathOrHandle: string | FileSystemDirectoryHandle, destinationPathOrHandle: string | FileSystemDirectoryHandle, { overwrite, rootDir, recursive }?: CopyDirOptions): Promise<void>;
+export interface CopyFileOptions {
+    /** Creates the destination directory structure if it doesn't exist. Throws an error otherwise */
+    recursive?: boolean;
+    /** Overwrites the file in the destination if it already exists. */
+    overwrite?: boolean;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Copies a file from one location to another.
+ *
+ * @param sourcePathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the source file.
+ * @param destinationPathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the destination file.
+ * @param options The options for function.
+ */
+export declare function copyFile(sourcePathOrHandle: string | FileSystemFileHandle, destinationPathOrHandle: string | FileSystemFileHandle, { overwrite, rootDir, recursive }?: CopyDirOptions): Promise<void>;
+export interface MoveDirOptions {
+    /** Creates the destination directory structure if it doesn't exist. Throws an error otherwise */
+    recursive?: boolean;
+    /** Overwrites existing files in the destination. */
+    overwrite?: boolean;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Moves a directory from one location to another.
+ *
+ * @param sourcePathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the source directory.
+ * @param destinationPathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the destination directory.
+ * @param options The options for function.
+ */
+export declare function moveDir(sourcePathOrHandle: string | FileSystemDirectoryHandle, destinationPathOrHandle: string | FileSystemDirectoryHandle, { overwrite, rootDir, recursive }?: CopyDirOptions): Promise<void>;
+export interface MoveFileOptions {
+    /** Creates the destination directory structure if it doesn't exist. Throws an error otherwise */
+    recursive?: boolean;
+    /** Overwrites the file in the destination if it already exists. */
+    overwrite?: boolean;
+    /**
+     * The file system root directory to resolve against. If not provided the Origin Private File System root will be used.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API#origin_private_file_system|MDN Reference}
+     */
+    rootDir?: FileSystemDirectoryHandle;
+}
+/**
+ * Moves a file from one location to another.
+ *
+ * @param sourcePathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the source file.
+ * @param destinationPathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the destination file.
+ * @param options The options for function.
+ */
+export declare function moveFile(sourcePathOrHandle: string | FileSystemFileHandle, destinationPathOrHandle: string | FileSystemFileHandle, { overwrite, rootDir, recursive }?: CopyDirOptions): Promise<void>;

package/dist/opfs.js

@@ -0,0 +1,283 @@
+// oxlint-disable max-lines
+import { basename, dirname, pathToSegments, resolve } from "./path.js";
+import { requestHandlePermissions } from "./permissions.js";
+/**
+ * Gets the directory handle for a given path.
+ *
+ * @param path The path to get a directory handle.
+ * @param options The options for function.
+ */
+export async function getDirHandle(path, { rootDir, recursive } = {}) {
+    const segments = pathToSegments(resolve(path));
+    let currentDirHandle = rootDir ?? await navigator.storage.getDirectory();
+    await requestHandlePermissions(currentDirHandle, 'read');
+    for (const segment of segments) {
+        // oxlint-disable-next-line no-await-in-loop
+        currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: recursive });
+        // oxlint-disable-next-line no-await-in-loop
+        await requestHandlePermissions(currentDirHandle, 'read');
+    }
+    return currentDirHandle;
+}
+/**
+ * Resolves the parent item for this path or handle.
+ *
+ * If the root of the file system is passed, it returns the root itself.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param options The options for function.
+ */
+export async function resolveParentHandle(pathOrHandle, { recursive, rootDir } = {}) {
+    const resolvedRootDir = rootDir ?? await navigator.storage.getDirectory();
+    let resolvedPath;
+    if (typeof pathOrHandle === 'string') {
+        resolvedPath = resolve(pathOrHandle);
+    }
+    else {
+        resolvedPath = resolve((await resolvedRootDir.resolve(pathOrHandle) ?? []).join('/'));
+    }
+    const parentDirPath = dirname(resolvedPath);
+    const parentDirHandle = await getDirHandle(parentDirPath, { rootDir, recursive });
+    return {
+        parentHandle: parentDirHandle,
+        parentPath: parentDirPath,
+        name: basename(resolvedPath)
+    };
+}
+/**
+ * Gets a file handle for a given path. Optionally creating the file if it doesn't exist.
+ *
+ * @param path A path string for the file.
+ * @param options The options for function.
+ */
+export async function getFileHandle(path, { touch, recursive, rootDir } = {}) {
+    const resolvedPath = resolve(path);
+    const fileName = basename(resolvedPath);
+    const resolvedDir = dirname(resolvedPath);
+    const dirHandle = await getDirHandle(resolvedDir, { recursive, rootDir });
+    return dirHandle.getFileHandle(fileName, { create: touch });
+}
+export async function checkDirExists(path, { rootDir } = {}) {
+    try {
+        const { name, parentHandle } = await resolveParentHandle(path, { rootDir });
+        await parentHandle.getDirectoryHandle(name, { create: false });
+        return true;
+    }
+    catch (err) {
+        if (err.name === 'NotFoundError') {
+            return false;
+        }
+        throw err;
+    }
+}
+export async function checkFileExists(path, { rootDir } = {}) {
+    try {
+        const { name, parentHandle } = await resolveParentHandle(path, { rootDir });
+        await parentHandle.getFileHandle(name, { create: false });
+        return true;
+    }
+    catch (err) {
+        if (err.name === 'NotFoundError') {
+            return false;
+        }
+        throw err;
+    }
+}
+/**
+ * Lists the directory contents recursivelly up to the `depth` provided.
+ *
+ * It returns an array of items, if the item have children and the depth is not exceeded, the children property will be filled.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param options The options for function.
+ */
+export async function listDirEntries(pathOrHandle, { depth = 0, rootDir } = {}) {
+    const { name, parentHandle, parentPath } = await resolveParentHandle(pathOrHandle, { rootDir });
+    const resolvedRootHandle = rootDir ?? await navigator.storage.getDirectory();
+    const dirHandle = (parentPath === '/' && name === '') ? resolvedRootHandle : await parentHandle.getDirectoryHandle(name);
+    async function getRecursiveEntries(curDirHandle, curDepth) {
+        const entries = [];
+        for await (const [name, entry] of curDirHandle.entries()) {
+            if (entry.kind === 'file' || curDepth >= depth) {
+                entries.push({
+                    name,
+                    handle: entry
+                });
+            }
+            else {
+                entries.push({
+                    name,
+                    handle: entry,
+                    children: await getRecursiveEntries(entry, curDepth + 1)
+                });
+            }
+        }
+        return entries;
+    }
+    return getRecursiveEntries(dirHandle, 0);
+}
+/**
+ * Write data to a file, overwriting existing data.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param data The data to write to the file.
+ * @param options The options for function.
+ */
+export async function writeFile(pathOrHandle, data, { recursive = true, rootDir, overwrite = true } = {}) {
+    const { name, parentHandle } = await resolveParentHandle(pathOrHandle, { recursive: recursive, rootDir });
+    const fileHandle = await parentHandle.getFileHandle(name, { create: true });
+    const file = await fileHandle.getFile();
+    if (file.size && !overwrite) {
+        throw new DOMException('Cannot overwrite existing file', 'NotAllowedError');
+    }
+    await requestHandlePermissions(fileHandle, 'readwrite');
+    const stream = await fileHandle.createWritable();
+    await stream.truncate(0);
+    await stream.write(data);
+    await stream.close();
+}
+/**
+ * Appends data to the end of a file.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param data The data to append to the file.
+ * @param options The options for function.
+ */
+export async function appendFile(pathOrHandle, data, { recursive, rootDir } = {}) {
+    const { name, parentHandle } = await resolveParentHandle(pathOrHandle, { recursive: recursive, rootDir });
+    const fileHandle = await parentHandle.getFileHandle(name, { create: true });
+    await requestHandlePermissions(fileHandle, 'readwrite');
+    const stream = await fileHandle.createWritable({ keepExistingData: true });
+    const file = await fileHandle.getFile();
+    await stream.seek(file.size);
+    await stream.write(data);
+    await stream.close();
+}
+/**
+ * Deletes a directory, optionally also deleting it's contents recursivelly.
+ *
+ * If the directory is the root of the file system, all children will be deleted but the root directory itself will be kept.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param options The options for function.
+ */
+export async function removeDir(pathOrHandle, { recursive, rootDir }) {
+    const { name, parentHandle, parentPath } = await resolveParentHandle(pathOrHandle, { rootDir });
+    if (parentPath === '/' && name === '') {
+        await requestHandlePermissions(parentHandle, 'readwrite');
+        for await (const childName of parentHandle.keys()) {
+            await parentHandle.removeEntry(childName, { recursive });
+        }
+        return;
+    }
+    const dirHandle = await parentHandle.getDirectoryHandle(name);
+    const entries = await listDirEntries(dirHandle, { rootDir, depth: 0 });
+    for (const entry of entries) {
+        // oxlint-disable-next-line no-await-in-loop
+        await parentHandle.removeEntry(entry.name, { recursive });
+    }
+    await parentHandle.removeEntry(name, { recursive });
+}
+/**
+ * Deletes a file.
+ *
+ * @param pathOrHandle A path string or a {@link FileSystemHandle}
+ * @param options The options for function.
+ */
+export async function removeFile(pathOrHandle, { rootDir } = {}) {
+    const { name, parentHandle } = await resolveParentHandle(pathOrHandle, { rootDir });
+    const fileHandle = await parentHandle.getFileHandle(name);
+    await requestHandlePermissions(fileHandle, 'readwrite');
+    await requestHandlePermissions(parentHandle, 'readwrite');
+    await parentHandle.removeEntry(name);
+}
+/**
+ * Copies a directory from one location to another.
+ *
+ * @param sourcePathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the source directory.
+ * @param destinationPathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the destination directory.
+ * @param options The options for function.
+ */
+export async function copyDir(sourcePathOrHandle, destinationPathOrHandle, { overwrite = true, rootDir, recursive = true } = {}) {
+    const entries = await listDirEntries(sourcePathOrHandle, { depth: Infinity, rootDir });
+    const { name: destName, parentHandle: destParentHandle } = await resolveParentHandle(destinationPathOrHandle, { recursive, rootDir });
+    const destHandle = await destParentHandle.getDirectoryHandle(destName);
+    async function copyRecursive(items, currentDestHandle) {
+        for (const item of items) {
+            const handle = item.handle;
+            // oxlint-disable no-await-in-loop
+            if (handle instanceof FileSystemFileHandle) {
+                const destFileHandle = await currentDestHandle.getFileHandle(item.name, { create: true });
+                // oxlint-disable-next-line no-use-before-define
+                await copyFile(handle, destFileHandle, { recursive, rootDir, overwrite });
+            }
+            else if (item.children) {
+                const newDestDirHandle = await currentDestHandle.getDirectoryHandle(item.name, { create: true });
+                await copyRecursive(item.children, newDestDirHandle);
+            }
+            // oxlint-enable no-await-in-loop
+        }
+    }
+    await copyRecursive(entries, destHandle);
+}
+/**
+ * Copies a file from one location to another.
+ *
+ * @param sourcePathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the source file.
+ * @param destinationPathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the destination file.
+ * @param options The options for function.
+ */
+export async function copyFile(sourcePathOrHandle, destinationPathOrHandle, { overwrite = true, rootDir, recursive = true } = {}) {
+    let sourceHandle;
+    if (typeof sourcePathOrHandle === 'string') {
+        sourceHandle = await getFileHandle(sourcePathOrHandle, { rootDir });
+    }
+    else {
+        sourceHandle = sourcePathOrHandle;
+    }
+    const file = await sourceHandle.getFile();
+    await writeFile(destinationPathOrHandle, await file.arrayBuffer(), { rootDir, recursive, overwrite });
+}
+/**
+ * Moves a directory from one location to another.
+ *
+ * @param sourcePathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the source directory.
+ * @param destinationPathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the destination directory.
+ * @param options The options for function.
+ */
+export async function moveDir(sourcePathOrHandle, destinationPathOrHandle, { overwrite = true, rootDir, recursive = true } = {}) {
+    const entries = await listDirEntries(sourcePathOrHandle, { depth: Infinity, rootDir });
+    const { name: destName, parentHandle: destParentHandle } = await resolveParentHandle(destinationPathOrHandle, { recursive, rootDir });
+    const destHandle = await destParentHandle.getDirectoryHandle(destName);
+    async function moveRecursive(items, currentDestHandle) {
+        for (const item of items) {
+            const handle = item.handle;
+            // oxlint-disable no-await-in-loop
+            if (handle instanceof FileSystemFileHandle) {
+                const destFileHandle = await currentDestHandle.getFileHandle(item.name, { create: true });
+                // oxlint-disable-next-line no-use-before-define
+                await moveFile(handle, destFileHandle, { recursive, rootDir, overwrite });
+            }
+            else if (item.children) {
+                const newDestDirHandle = await currentDestHandle.getDirectoryHandle(item.name, { create: true });
+                await moveRecursive(item.children, newDestDirHandle);
+                // oxlint-disable-next-line typescript/consistent-type-assertions, typescript/no-unsafe-type-assertion
+                await removeDir(handle, { recursive: true, rootDir });
+            }
+            // oxlint-enable no-await-in-loop
+        }
+    }
+    await moveRecursive(entries, destHandle);
+}
+/**
+ * Moves a file from one location to another.
+ *
+ * @param sourcePathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the source file.
+ * @param destinationPathOrHandle The path string or a {@link FileSystemDirectoryHandle} for the destination file.
+ * @param options The options for function.
+ */
+export async function moveFile(sourcePathOrHandle, destinationPathOrHandle, { overwrite = true, rootDir, recursive = true } = {}) {
+    await copyFile(sourcePathOrHandle, destinationPathOrHandle, { overwrite, rootDir, recursive });
+    await removeFile(sourcePathOrHandle, { rootDir });
+}
+// #endregion

package/dist/path.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Split a path string into segments and normalize it.
+ *
+ * The normalization does the following:
+ * - Removes empty path segments.
+ * - Decode from URI parts to handle paths coming from URLs.
+ *
+ * @param path The path to split into segments
+ */
+export declare function pathToSegments(path: string): string[];
+/**
+ * Returns the directory name, given a path string.
+ * It is similar to node's `dirname` fucntion.
+ *
+ * @param path The path to get the directory name
+ */
+export declare function dirname(path: string): string;
+/**
+ * Returns the name for the last part of a given path string.
+ * It is similar to node's `basename` function.
+ *
+ * @param path The path to get the last part.
+ * @param suffix An optional extension to remove from the item, like an extension.
+ */
+export declare function basename(path: string, suffix?: string): string;
+/**
+ * Returns the extension of the path, from the last occurrence of the `.` (dot) to the end of the string.
+ * Returns an empty string if there is no dot or if the only dot is in the start of the string.
+ * It is similar to node's `extname` function.
+ *
+ * @param path The path to get the extension
+ */
+export declare function extname(path: string): string;
+/**
+ * Resolves a sequence of paths or path segments into an absolute path.
+ * It is similar to node's `resolve` function.
+ *
+ * **Note**: If no absolute path is provided, the function prepends a `/`. It assumes the starting point is _always_ the file system root.
+ *
+ * @param paths A sequence of paths or path segments
+ */
+export declare function resolve(...paths: string[]): string;
+/**
+ * Encodes a path string, taking care of restricted characters and names and converting them to percent encoded characters.
+ *
+ * @param path The path to encode.
+ * @param replacer A custom replacer function that will be invoked for each segment of the path.
+ */
+export declare function encodePath(path: string, replacer?: (segment: string) => string): string;
+/**
+ * Decodes a path string, converting back from perdent encoded characters.
+ *
+ * @param path The path to decode.
+ * @param replacer A custom replacer function that will be invoked for each segment of the path.
+ */
+export declare function decodePath(path: string, replacer?: (segment: string) => string): string;