@cetapod/react-native-smb 1.0.0

package/lib/core/taskResult.d.ts

@@ -0,0 +1,3 @@
+import type { SmbTask } from './SmbTask';
+/** Subscribe once, resolve or reject when the task reaches a terminal status. */
+export declare function taskResult<T>(task: SmbTask<T>): Promise<T>;

package/lib/core/taskResult.js

@@ -0,0 +1,52 @@
+import { terminalStatus } from '../bridge/decode';
+import { SmbError, SmbTaskError, TaskStatus } from '../types';
+function errorForStatus(status, raw, taskId) {
+    const code = parseInt(raw.errorCode ?? '0', 10);
+    const message = raw.errorMessage || (status === TaskStatus.Cancelled ? 'Task cancelled' : 'Task failed');
+    return new SmbTaskError(message, Number.isFinite(code) ? code : SmbError.Unknown, taskId);
+}
+/** Subscribe once, resolve or reject when the task reaches a terminal status. */
+export function taskResult(task) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (status, raw) => {
+            if (settled)
+                return;
+            settled = true;
+            if (status === TaskStatus.Success) {
+                try {
+                    resolve(task.getResultValue());
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }
+            else {
+                reject(errorForStatus(status, raw, task.id));
+            }
+        };
+        const unsub = task.subscribe((snap) => {
+            if (snap.status === TaskStatus.Success ||
+                snap.status === TaskStatus.Error ||
+                snap.status === TaskStatus.Cancelled) {
+                finish(snap.status, {
+                    errorCode: String(snap.errorCode),
+                    errorMessage: snap.errorMessage,
+                });
+                unsub();
+            }
+        });
+        try {
+            const raw = task.getRaw();
+            const status = terminalStatus(raw);
+            if (status !== null) {
+                finish(status, raw);
+                unsub();
+            }
+        }
+        catch (e) {
+            unsub();
+            reject(e);
+        }
+    });
+}

package/lib/hooks/useSubscribe.d.ts

@@ -0,0 +1,20 @@
+import type { SmbTask } from '../core/SmbTask';
+import { TaskStatus, type SmbTaskState } from '../types';
+export interface SubscribeHandle<T = void> {
+    /** Start live updates. Returns unsubscribe. */
+    subscribe: (listener?: (snapshot: SmbTaskState) => void) => () => void;
+    cancel: () => void;
+    progress: number;
+    status: TaskStatus;
+    snapshot: SmbTaskState | null;
+    task: SmbTask<T> | null;
+}
+/**
+ * React binding for {@link SmbTask.subscribe}. Subscribes automatically on mount
+ * and whenever `task` changes; unsubscribes on unmount / task change.
+ *
+ * @example
+ * const task = smb.downloadFile(remote, local);
+ * const { progress, status, cancel } = useSubscribe(task);
+ */
+export declare function useSubscribe<T>(task: SmbTask<T> | null | undefined): SubscribeHandle<T>;

package/lib/hooks/useSubscribe.js

@@ -0,0 +1,36 @@
+import { useCallback, useEffect, useState } from 'react';
+import { TaskStatus } from '../types';
+/**
+ * React binding for {@link SmbTask.subscribe}. Subscribes automatically on mount
+ * and whenever `task` changes; unsubscribes on unmount / task change.
+ *
+ * @example
+ * const task = smb.downloadFile(remote, local);
+ * const { progress, status, cancel } = useSubscribe(task);
+ */
+export function useSubscribe(task) {
+    const [snapshot, setSnapshot] = useState(() => task?.get() ?? null);
+    const subscribe = useCallback((listener) => {
+        if (!task)
+            return () => { };
+        return task.subscribe((snap) => {
+            setSnapshot(snap);
+            listener?.(snap);
+        });
+    }, [task]);
+    useEffect(() => {
+        setSnapshot(task?.get() ?? null);
+        return subscribe();
+    }, [task, subscribe]);
+    const cancel = useCallback(() => {
+        task?.cancel();
+    }, [task]);
+    return {
+        subscribe,
+        cancel,
+        progress: snapshot?.progress ?? task?.progress ?? 0,
+        status: snapshot?.status ?? task?.status ?? TaskStatus.Pending,
+        snapshot,
+        task: task ?? null,
+    };
+}

package/lib/hooks/useTransfers.d.ts

@@ -0,0 +1,7 @@
+import type { Smb } from '../core/SMB';
+import type { SmbTaskState } from '../types';
+export declare function useTransfers(smb: Smb | null): SmbTaskState[];
+export declare function useTransferActions(smb: Smb | null): {
+    clearCompleted: () => void | undefined;
+    hide: (taskId: string) => void | undefined;
+};

package/lib/hooks/useTransfers.js

@@ -0,0 +1,29 @@
+import { useEffect, useMemo, useState } from 'react';
+const EMPTY_TASKS = [];
+function store(smb) {
+    return smb.transferStore();
+}
+export function useTransfers(smb) {
+    const [tasks, setTasks] = useState(EMPTY_TASKS);
+    useEffect(() => {
+        if (!smb) {
+            setTasks(EMPTY_TASKS);
+            return undefined;
+        }
+        const transferStore = store(smb);
+        const onStoreChange = () => {
+            setTasks(transferStore.getSnapshot());
+        };
+        const unsubscribe = transferStore.subscribe(onStoreChange);
+        onStoreChange();
+        return unsubscribe;
+    }, [smb]);
+    return smb ? tasks : EMPTY_TASKS;
+}
+export function useTransferActions(smb) {
+    const s = smb ? store(smb) : null;
+    return useMemo(() => ({
+        clearCompleted: () => s?.clearCompleted(),
+        hide: (taskId) => s?.hide(taskId),
+    }), [s]);
+}

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './utils';
+export { SMB, type Smb } from './core/SMB';
+export { SmbTask } from './core/SmbTask';
+export { useSubscribe, type SubscribeHandle } from './hooks/useSubscribe';
+export { useTransfers, useTransferActions } from './hooks/useTransfers';
+export { statusLabel, operationLabel, isTransferKind, isDeterminateKind, isTerminalStatus, } from './labels';

package/lib/index.js

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './utils';
+export { SMB } from './core/SMB';
+export { SmbTask } from './core/SmbTask';
+export { useSubscribe } from './hooks/useSubscribe';
+export { useTransfers, useTransferActions } from './hooks/useTransfers';
+export { statusLabel, operationLabel, isTransferKind, isDeterminateKind, isTerminalStatus, } from './labels';

package/lib/labels.d.ts

@@ -0,0 +1,6 @@
+import { SmbOperatorKind, TaskStatus } from './types';
+export declare function statusLabel(status: TaskStatus): string;
+export declare function operationLabel(kind: SmbOperatorKind): string;
+export declare function isTransferKind(kind: SmbOperatorKind): boolean;
+export declare function isDeterminateKind(kind: SmbOperatorKind): boolean;
+export declare function isTerminalStatus(status: TaskStatus): boolean;

package/lib/labels.js

@@ -0,0 +1,71 @@
+import { SmbOperatorKind, TaskStatus } from './types';
+export function statusLabel(status) {
+    switch (status) {
+        case TaskStatus.Idle:
+            return 'idle';
+        case TaskStatus.Pending:
+            return 'pending';
+        case TaskStatus.Running:
+            return 'running';
+        case TaskStatus.Success:
+            return 'success';
+        case TaskStatus.Error:
+            return 'error';
+        case TaskStatus.Cancelled:
+            return 'cancelled';
+        default:
+            return 'unknown';
+    }
+}
+export function operationLabel(kind) {
+    switch (kind) {
+        case SmbOperatorKind.Initialize:
+            return 'Initialize';
+        case SmbOperatorKind.Connect:
+            return 'Connect';
+        case SmbOperatorKind.ConnectShare:
+            return 'Connect share';
+        case SmbOperatorKind.Disconnect:
+            return 'Disconnect';
+        case SmbOperatorKind.ListShares:
+            return 'List shares';
+        case SmbOperatorKind.ListDirectory:
+            return 'List directory';
+        case SmbOperatorKind.GetPathInfo:
+            return 'Get info';
+        case SmbOperatorKind.GetSecurityDescriptor:
+            return 'Get ACL';
+        case SmbOperatorKind.DownloadFile:
+            return 'Download';
+        case SmbOperatorKind.UploadFile:
+            return 'Upload';
+        case SmbOperatorKind.CreateDirectory:
+            return 'Create folder';
+        case SmbOperatorKind.DeleteItem:
+            return 'Delete';
+        case SmbOperatorKind.MoveItem:
+            return 'Move';
+        case SmbOperatorKind.RenameItem:
+            return 'Rename';
+        case SmbOperatorKind.CopyItem:
+            return 'Copy';
+        case SmbOperatorKind.DuplicateItem:
+            return 'Duplicate';
+        default:
+            return 'Unknown';
+    }
+}
+export function isTransferKind(kind) {
+    return (kind === SmbOperatorKind.DownloadFile ||
+        kind === SmbOperatorKind.UploadFile ||
+        kind === SmbOperatorKind.CopyItem ||
+        kind === SmbOperatorKind.DuplicateItem);
+}
+export function isDeterminateKind(kind) {
+    return isTransferKind(kind);
+}
+export function isTerminalStatus(status) {
+    return (status === TaskStatus.Success ||
+        status === TaskStatus.Error ||
+        status === TaskStatus.Cancelled);
+}

package/lib/types.d.ts

@@ -0,0 +1,141 @@
+export interface SmbCredentials {
+    readonly username: string;
+    readonly password: string;
+}
+export interface SmbShareList {
+    readonly name: string;
+    readonly comment: string;
+}
+export interface SmbConnectionInfo {
+    readonly url: string;
+    readonly server: string;
+    readonly share: string;
+    readonly isConnected: boolean;
+}
+export declare enum SmbError {
+    Unknown = 0,
+    Cancelled = 1,
+    InvalidArgument = 100,
+    NotFound = 101,
+    AlreadyExists = 102,
+    AccessDenied = 103,
+    NotDirectory = 104,
+    IsDirectory = 105,
+    DirectoryNotEmpty = 106,
+    NotConnected = 200,
+    ConnectionRefused = 201,
+    TimedOut = 202,
+    Busy = 300,
+    NoSpace = 301,
+    Io = 302
+}
+export declare class SmbTaskError extends Error {
+    readonly code: SmbError;
+    readonly taskId?: string;
+    constructor(message: string, code?: SmbError, taskId?: string);
+}
+export interface SmbFileInfo {
+    readonly name: string;
+    readonly path: string;
+    readonly size: number;
+    readonly isDirectory: boolean;
+    readonly modifiedAt: number;
+    readonly accessedAt: number;
+    readonly createdAt: number;
+    readonly changedAt: number;
+    readonly childCount?: number;
+    readonly children?: SmbFileInfo[];
+}
+export interface SmbAce {
+    readonly aceType: string;
+    readonly aceFlags: string[];
+    readonly mask: string[];
+    readonly sid: string;
+}
+export interface SmbAcl {
+    readonly revision: number;
+    readonly aceCount: number;
+    readonly aces: SmbAce[];
+}
+export interface SmbSecurityDescriptor {
+    readonly revision: number;
+    readonly control: string[];
+    readonly ownerSid: string;
+    readonly groupSid: string;
+    readonly dacl: SmbAcl;
+}
+export interface PathComponents {
+    readonly parentDirectory: string;
+    readonly baseFileName: string;
+    readonly extension: string;
+    readonly fullFileName: string;
+}
+export declare enum TaskStatus {
+    Idle = 0,
+    Pending = 1,
+    Running = 2,
+    Success = 3,
+    Error = 4,
+    Cancelled = 5
+}
+export declare enum SmbOperatorKind {
+    Initialize = 0,
+    Connect = 1,
+    ConnectShare = 2,
+    Disconnect = 3,
+    ListShares = 4,
+    ListDirectory = 5,
+    GetPathInfo = 6,
+    GetSecurityDescriptor = 7,
+    DownloadFile = 8,
+    UploadFile = 9,
+    CreateDirectory = 10,
+    DeleteItem = 11,
+    MoveItem = 12,
+    RenameItem = 13,
+    CopyItem = 14,
+    DuplicateItem = 15
+}
+export declare enum SlotState {
+    Idle = 0,
+    Assigned = 1,
+    Activating = 2
+}
+export interface SmbTaskState {
+    readonly taskId: string;
+    readonly kind: SmbOperatorKind;
+    readonly status: TaskStatus;
+    readonly determinate: boolean;
+    readonly progress: number;
+    readonly bytesDone: number;
+    readonly totalBytes: number;
+    readonly bytesPerSecond: number;
+    readonly etaSeconds: number;
+    readonly sourcePath: string;
+    readonly destinationPath: string;
+    readonly errorCode: number;
+    readonly errorMessage: string;
+    readonly startedAt: number;
+    readonly updatedAt: number;
+    readonly endedAt: number;
+}
+export interface PoolSlotInfo {
+    readonly index: number;
+    readonly interactiveOnly: boolean;
+    readonly state: SlotState;
+    readonly isConnected: boolean;
+    readonly shareName: string;
+    readonly taskId: string;
+    readonly kind: SmbOperatorKind;
+}
+export interface PoolInfo {
+    readonly poolSize: number;
+    readonly slots: PoolSlotInfo[];
+}
+export interface NativeSmbTask {
+    cancel(): void;
+    get(): Record<string, string>;
+    subscribe(listener: (snapshot: Record<string, string>) => void): string;
+    unsubscribe(subscriptionId: string): void;
+    getResultValue(): unknown;
+}

package/lib/types.js

@@ -0,0 +1,59 @@
+export var SmbError;
+(function (SmbError) {
+    SmbError[SmbError["Unknown"] = 0] = "Unknown";
+    SmbError[SmbError["Cancelled"] = 1] = "Cancelled";
+    SmbError[SmbError["InvalidArgument"] = 100] = "InvalidArgument";
+    SmbError[SmbError["NotFound"] = 101] = "NotFound";
+    SmbError[SmbError["AlreadyExists"] = 102] = "AlreadyExists";
+    SmbError[SmbError["AccessDenied"] = 103] = "AccessDenied";
+    SmbError[SmbError["NotDirectory"] = 104] = "NotDirectory";
+    SmbError[SmbError["IsDirectory"] = 105] = "IsDirectory";
+    SmbError[SmbError["DirectoryNotEmpty"] = 106] = "DirectoryNotEmpty";
+    SmbError[SmbError["NotConnected"] = 200] = "NotConnected";
+    SmbError[SmbError["ConnectionRefused"] = 201] = "ConnectionRefused";
+    SmbError[SmbError["TimedOut"] = 202] = "TimedOut";
+    SmbError[SmbError["Busy"] = 300] = "Busy";
+    SmbError[SmbError["NoSpace"] = 301] = "NoSpace";
+    SmbError[SmbError["Io"] = 302] = "Io";
+})(SmbError || (SmbError = {}));
+export class SmbTaskError extends Error {
+    constructor(message, code = SmbError.Unknown, taskId) {
+        super(message);
+        this.code = code;
+        this.taskId = taskId;
+    }
+}
+export var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus[TaskStatus["Idle"] = 0] = "Idle";
+    TaskStatus[TaskStatus["Pending"] = 1] = "Pending";
+    TaskStatus[TaskStatus["Running"] = 2] = "Running";
+    TaskStatus[TaskStatus["Success"] = 3] = "Success";
+    TaskStatus[TaskStatus["Error"] = 4] = "Error";
+    TaskStatus[TaskStatus["Cancelled"] = 5] = "Cancelled";
+})(TaskStatus || (TaskStatus = {}));
+export var SmbOperatorKind;
+(function (SmbOperatorKind) {
+    SmbOperatorKind[SmbOperatorKind["Initialize"] = 0] = "Initialize";
+    SmbOperatorKind[SmbOperatorKind["Connect"] = 1] = "Connect";
+    SmbOperatorKind[SmbOperatorKind["ConnectShare"] = 2] = "ConnectShare";
+    SmbOperatorKind[SmbOperatorKind["Disconnect"] = 3] = "Disconnect";
+    SmbOperatorKind[SmbOperatorKind["ListShares"] = 4] = "ListShares";
+    SmbOperatorKind[SmbOperatorKind["ListDirectory"] = 5] = "ListDirectory";
+    SmbOperatorKind[SmbOperatorKind["GetPathInfo"] = 6] = "GetPathInfo";
+    SmbOperatorKind[SmbOperatorKind["GetSecurityDescriptor"] = 7] = "GetSecurityDescriptor";
+    SmbOperatorKind[SmbOperatorKind["DownloadFile"] = 8] = "DownloadFile";
+    SmbOperatorKind[SmbOperatorKind["UploadFile"] = 9] = "UploadFile";
+    SmbOperatorKind[SmbOperatorKind["CreateDirectory"] = 10] = "CreateDirectory";
+    SmbOperatorKind[SmbOperatorKind["DeleteItem"] = 11] = "DeleteItem";
+    SmbOperatorKind[SmbOperatorKind["MoveItem"] = 12] = "MoveItem";
+    SmbOperatorKind[SmbOperatorKind["RenameItem"] = 13] = "RenameItem";
+    SmbOperatorKind[SmbOperatorKind["CopyItem"] = 14] = "CopyItem";
+    SmbOperatorKind[SmbOperatorKind["DuplicateItem"] = 15] = "DuplicateItem";
+})(SmbOperatorKind || (SmbOperatorKind = {}));
+export var SlotState;
+(function (SlotState) {
+    SlotState[SlotState["Idle"] = 0] = "Idle";
+    SlotState[SlotState["Assigned"] = 1] = "Assigned";
+    SlotState[SlotState["Activating"] = 2] = "Activating";
+})(SlotState || (SlotState = {}));

package/lib/utils.d.ts

@@ -0,0 +1,79 @@
+import type { PathComponents } from './types';
+/**
+ * Normalize a path to use forward slashes and remove trailing slashes
+ * @param path - The path to normalize
+ * @returns The normalized path
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * Split a file path into its components
+ * @param path - The full path to split
+ * @returns PathComponents containing parent directory, base filename, extension, and full filename
+ *
+ * @example
+ * splitPath('/folder/document.pdf')
+ * // Returns:
+ * // {
+ * //   parentDirectory: '/folder',
+ * //   baseFileName: 'document',
+ * //   extension: '.pdf',
+ * //   fullFileName: 'document.pdf'
+ * // }
+ */
+export declare function splitPath(path: string): PathComponents;
+/**
+ * Join path components into a full path
+ * @param directory - The directory path
+ * @param filename - The filename to append
+ * @returns The combined path
+ *
+ * @example
+ * joinPath('/folder', 'file.txt') // '/folder/file.txt'
+ * joinPath('/', 'file.txt') // '/file.txt'
+ */
+export declare function joinPath(directory: string, filename: string): string;
+/**
+ * Generate a unique copy name for duplicating files/folders
+ * Creates names in the format: "name copy.ext", "name copy 2.ext", etc.
+ *
+ * @param baseName - The base filename without extension
+ * @param extension - The file extension (including the dot)
+ * @param existingNames - Array of existing filenames to check against
+ * @returns The new unique name
+ *
+ * @example
+ * generateCopyName('document', '.pdf', ['document.pdf', 'document copy.pdf'])
+ * // Returns: 'document copy 2.pdf'
+ */
+export declare function generateCopyName(baseName: string, extension: string, existingNames: string[]): string;
+/**
+ * Get the parent directory of a path
+ * @param path - The path to get parent from
+ * @returns The parent directory path
+ *
+ * @example
+ * getParentPath('/folder/subfolder/file.txt') // '/folder/subfolder'
+ * getParentPath('/file.txt') // '/'
+ */
+export declare function getParentPath(path: string): string;
+/**
+ * Get just the filename from a full path
+ * @param path - The full path
+ * @returns The filename
+ *
+ * @example
+ * getFileName('/folder/document.pdf') // 'document.pdf'
+ */
+export declare function getFileName(path: string): string;
+/**
+ * Format file size in human-readable format
+ * @param bytes - Size in bytes
+ * @returns Formatted string (e.g., "1.5 MB")
+ */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * Format a timestamp to a readable date string
+ * @param timestamp - Unix timestamp in seconds
+ * @returns Formatted date string
+ */
+export declare function formatDate(timestamp: number): string;

package/lib/utils.js

@@ -0,0 +1,153 @@
+/**
+ * Normalize a path to use forward slashes and remove trailing slashes
+ * @param path - The path to normalize
+ * @returns The normalized path
+ */
+export function normalizePath(path) {
+    const normalized = path.replace(/\\/g, '/');
+    return normalized === '/' ? normalized : normalized.replace(/\/+$/, '');
+}
+/**
+ * Split a file path into its components
+ * @param path - The full path to split
+ * @returns PathComponents containing parent directory, base filename, extension, and full filename
+ *
+ * @example
+ * splitPath('/folder/document.pdf')
+ * // Returns:
+ * // {
+ * //   parentDirectory: '/folder',
+ * //   baseFileName: 'document',
+ * //   extension: '.pdf',
+ * //   fullFileName: 'document.pdf'
+ * // }
+ */
+export function splitPath(path) {
+    const normalizedPath = normalizePath(path);
+    const lastSlashIndex = normalizedPath.lastIndexOf('/');
+    const parentDirectory = lastSlashIndex >= 0
+        ? normalizedPath.substring(0, lastSlashIndex) || '/'
+        : '/';
+    const fullFileName = lastSlashIndex >= 0
+        ? normalizedPath.substring(lastSlashIndex + 1)
+        : normalizedPath;
+    const lastDotIndex = fullFileName.lastIndexOf('.');
+    const hasExtension = lastDotIndex > 0;
+    const baseFileName = hasExtension
+        ? fullFileName.substring(0, lastDotIndex)
+        : fullFileName;
+    const extension = hasExtension
+        ? fullFileName.substring(lastDotIndex)
+        : '';
+    return {
+        parentDirectory,
+        baseFileName,
+        extension,
+        fullFileName,
+    };
+}
+/**
+ * Join path components into a full path
+ * @param directory - The directory path
+ * @param filename - The filename to append
+ * @returns The combined path
+ *
+ * @example
+ * joinPath('/folder', 'file.txt') // '/folder/file.txt'
+ * joinPath('/', 'file.txt') // '/file.txt'
+ */
+export function joinPath(directory, filename) {
+    if (directory === '/') {
+        return `/${filename}`;
+    }
+    return directory.endsWith('/')
+        ? `${directory}${filename}`
+        : `${directory}/${filename}`;
+}
+/**
+ * Generate a unique copy name for duplicating files/folders
+ * Creates names in the format: "name copy.ext", "name copy 2.ext", etc.
+ *
+ * @param baseName - The base filename without extension
+ * @param extension - The file extension (including the dot)
+ * @param existingNames - Array of existing filenames to check against
+ * @returns The new unique name
+ *
+ * @example
+ * generateCopyName('document', '.pdf', ['document.pdf', 'document copy.pdf'])
+ * // Returns: 'document copy 2.pdf'
+ */
+export function generateCopyName(baseName, extension, existingNames) {
+    const copyPattern = /^(.+?)( copy)( \d+)?$/;
+    const match = baseName.match(copyPattern);
+    const rootName = baseName.replace(/ copy( \d+)?$/, '');
+    const copyNumbers = [];
+    existingNames.forEach((name) => {
+        const { baseFileName } = splitPath(name);
+        const _match = baseFileName.match(copyPattern);
+        if (!_match || rootName !== _match[1]) {
+            return;
+        }
+        if (!_match[3]) {
+            copyNumbers.push(1);
+        }
+        else {
+            copyNumbers.push(parseInt(_match[3].trim(), 10));
+        }
+    });
+    let nextNumber = match ? parseInt(match[3]?.trim() || '1', 10) + 1 : 1;
+    while (copyNumbers.includes(nextNumber)) {
+        nextNumber++;
+    }
+    const copySuffix = nextNumber === 1 ? 'copy' : `copy ${nextNumber}`;
+    return `${rootName} ${copySuffix}${extension}`;
+}
+/**
+ * Get the parent directory of a path
+ * @param path - The path to get parent from
+ * @returns The parent directory path
+ *
+ * @example
+ * getParentPath('/folder/subfolder/file.txt') // '/folder/subfolder'
+ * getParentPath('/file.txt') // '/'
+ */
+export function getParentPath(path) {
+    const { parentDirectory } = splitPath(path);
+    return parentDirectory;
+}
+/**
+ * Get just the filename from a full path
+ * @param path - The full path
+ * @returns The filename
+ *
+ * @example
+ * getFileName('/folder/document.pdf') // 'document.pdf'
+ */
+export function getFileName(path) {
+    const { fullFileName } = splitPath(path);
+    return fullFileName;
+}
+/**
+ * Format file size in human-readable format
+ * @param bytes - Size in bytes
+ * @returns Formatted string (e.g., "1.5 MB")
+ */
+export function formatFileSize(bytes) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+/**
+ * Format a timestamp to a readable date string
+ * @param timestamp - Unix timestamp in seconds
+ * @returns Formatted date string
+ */
+export function formatDate(timestamp) {
+    if (!timestamp)
+        return 'N/A';
+    const date = new Date(timestamp * 1000);
+    return `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
+}