@truenewx/tnxet/src/ipc/file.ts

互联网技术解决方案：Electron扩展支持

import constants from '../constants.ts';
import request from './request.ts';

let separator: string = navigator.userAgent.includes('Win') ? '\\' : '/';

export function getSeparator(): string {
    return separator;
}

export function joinPath(...paths: string[]): string {
    let result = '';
    if (paths.length) {
        for (let path of paths) {
            if (path.startsWith(separator)) {
                path = path.substring(separator.length);
            }
            if (path.endsWith(separator)) {
                result += path;
            } else {
                result += path + separator;
            }
        }
        result = result.substring(0, result.length - 1);
    }
    return result;
}

/**
 * 获取指定路径的上级目录路径，含末尾的斜杠，以示该地址为目录而不是文件
 * @param path 路径
 * @returns 上级目录路径，如果没有上级目录，则返回null
 */
export function getParentDir(path: string): string | null {
    if ((separator === '\\' && !path.endsWith(':\\')) || (separator === '/' && path !== '/')) {
        let index = path.lastIndexOf(separator);
        if (index >= 0) {
            if (index === path.length - 1) { // 已斜杠结尾，则先去掉斜杠，以便于后续判断
                path = path.substring(0, index);
                index = path.lastIndexOf(separator);
            }
            if (index >= 0) {
                return path.substring(0, index + 1);
            }
        }
    }
    return null;
}

export function toRelativePath(basePath: string, baseIsFile: boolean, absolutePath: string): string {
    // 如果基础路径就是绝对路径的开头,直接截取后面的部分
    if (absolutePath.startsWith(basePath)) {
        let relativePath = absolutePath.substring(basePath.length);
        // 去掉开头的分隔符
        return relativePath.startsWith(separator) ? relativePath.substring(1) : relativePath;
    }

    // 将两个路径都分割成数组
    const absoluteSegments = absolutePath.split(separator);
    const baseSegments = basePath.split(separator);

    // 找到第一个不同的位置
    let i = 0;
    while (i < absoluteSegments.length && i < baseSegments.length && absoluteSegments[i] === baseSegments[i]) {
        i++;
    }

    // 构建相对路径
    let relativeSegmentLength = baseSegments.length - i;
    if (baseIsFile) {
        relativeSegmentLength--;
    }
    const relativeSegments = Array(relativeSegmentLength).fill('..')
        .concat(absoluteSegments.slice(i));

    // 使用'/'拼接最终结果
    return relativeSegments.join('/');
}

export function toAbsolutePath(basePath: string, baseIsFile: boolean, relativePath: string): string {
    // 将基础路径和相对路径分割成段
    const baseSegments = basePath.split(separator);
    const relativeSegments = relativePath.replace(/\\/g, '/').split('/');

    // 创建结果数组，初始化为基础路径的段
    let resultSegments = baseIsFile ? baseSegments.slice(0, baseSegments.length - 1) : [...baseSegments];

    // 处理每个相对路径段
    for (const segment of relativeSegments) {
        if (segment === '..') {
            // 如果遇到'..'，移除结果中的最后一段
            if (resultSegments.length > 0) {
                resultSegments.pop();
            }
        } else if (segment !== '.' && segment !== '') {
            // 如果不是'.'或空字符串，添加到结果中
            resultSegments.push(segment);
        }
    }

    // 使用系统分隔符拼接最终结果
    return resultSegments.join(separator);
}

export function getFileName(path: string): string | null {
    let index = path.lastIndexOf(separator);
    // 斜杠不是在末尾，才有文件名
    if (index < path.length - 1) {
        return path.substring(index + 1);
    }
    return null;
}

export async function loadSeparator(): Promise<string> {
    separator = await request<string>(constants.event.file.separator, []);
    return separator;
}

export function exists(path: string): Promise<boolean> {
    return request<boolean>(constants.event.file.exists, [path]);
}

export function read(path: string, dataIfNonexistent?: string): Promise<string> {
    return request<string>(constants.event.file.read, [path, dataIfNonexistent]);
}

export function write(path: string, data: string): Promise<void> {
    return request<void>(constants.event.file.write, [path, data]);
}

export function readAll(dir: string, pathRegex?: string): Promise<Record<string, string>> {
    return request<Record<string, string>>(constants.event.file.readAll, [dir, pathRegex]);
}

export function readData(path: string): Promise<FileData> {
    return request<FileData>(constants.event.file.readData, [path]);
}

export function findPath(dir: string, pathRegex?: string): Promise<string[]> {
    return request<string[]>(constants.event.file.findPath, [dir, pathRegex]);
}

export function del(path: string, deleteEmptyDir = false, throwIfAbsent = false): Promise<void> {
    return request<void>(constants.event.file.delete, [path, deleteEmptyDir, throwIfAbsent]);
}

export function copy(sourceFilePath: string, targetFilePath: string, force?: boolean): Promise<void> {
    return request<void>(constants.event.file.copy, [sourceFilePath, targetFilePath, force]);
}