clickgo-native 0.0.1-dev → 0.0.3-dev3

package/dist/lib/fs.js

@@ -0,0 +1,324 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyFile = exports.readDir = exports.rename = exports.chmod = exports.rmdir = exports.mkdir = exports.stats = exports.unlink = exports.symlink = exports.readLink = exports.putContent = exports.getContent = exports.refreshDrives = void 0;
+const fs = __importStar(require("fs"));
+const tool = __importStar(require("./tool"));
+const platform = process.platform;
+function formatPath(path) {
+    if (platform !== 'win32') {
+        return path;
+    }
+    if (path === '/') {
+        return path;
+    }
+    return path[1] + ':' + path.slice(2);
+}
+const drives = [];
+function refreshDrives() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (platform !== 'win32') {
+            return;
+        }
+        drives.length = 0;
+        for (let i = 0; i < 26; ++i) {
+            const char = String.fromCharCode(97 + i);
+            try {
+                yield fs.promises.stat(char + ':/');
+                drives.push(char);
+            }
+            catch (_a) {
+            }
+        }
+    });
+}
+exports.refreshDrives = refreshDrives;
+function getContent(path, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = formatPath(path);
+        const encoding = options.encoding;
+        const start = options.start;
+        const end = options.end;
+        if (start || end) {
+            return new Promise(function (resolve) {
+                const rs = fs.createReadStream(path, {
+                    'encoding': encoding,
+                    'start': start,
+                    'end': end
+                });
+                const data = [];
+                rs.on('data', function (chunk) {
+                    data.push(chunk);
+                }).on('end', function () {
+                    const buf = Buffer.concat(data);
+                    if (encoding) {
+                        resolve(buf.toString());
+                    }
+                    else {
+                        resolve(buf);
+                    }
+                }).on('error', function () {
+                    resolve(null);
+                });
+            });
+        }
+        else {
+            try {
+                if (encoding) {
+                    return yield fs.promises.readFile(path, {
+                        'encoding': encoding
+                    });
+                }
+                else {
+                    return yield fs.promises.readFile(path);
+                }
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+    });
+}
+exports.getContent = getContent;
+function putContent(path, data, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = formatPath(path);
+        try {
+            yield fs.promises.writeFile(path, data, options);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+exports.putContent = putContent;
+function readLink(path, encoding) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = formatPath(path);
+        try {
+            return yield fs.promises.readlink(path, {
+                'encoding': encoding
+            });
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+exports.readLink = readLink;
+function symlink(filePath, linkPath, type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        filePath = formatPath(filePath);
+        linkPath = formatPath(linkPath);
+        try {
+            yield fs.promises.symlink(filePath, linkPath, type);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+exports.symlink = symlink;
+function unlink(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = formatPath(path);
+        for (let i = 0; i <= 2; ++i) {
+            try {
+                yield fs.promises.unlink(path);
+                return true;
+            }
+            catch (_a) {
+                yield tool.sleep(250);
+            }
+        }
+        try {
+            yield fs.promises.unlink(path);
+            return true;
+        }
+        catch (_b) {
+            return false;
+        }
+    });
+}
+exports.unlink = unlink;
+function stats(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = formatPath(path);
+        try {
+            const item = yield fs.promises.lstat(path);
+            return {
+                isFile: item.isFile(),
+                isDirectory: item.isDirectory(),
+                isSymbolicLink: item.isSymbolicLink(),
+                'size': item.size,
+                'blksize': item.blksize,
+                'atimeMs': item.atimeMs,
+                'mtimeMs': item.mtimeMs,
+                'ctimeMs': item.ctimeMs,
+                'birthtimeMs': item.birthtimeMs,
+                'atime': item.atime,
+                'mtime': item.mtime,
+                'ctime': item.ctime,
+                'birthtime': item.birthtime
+            };
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+exports.stats = stats;
+function mkdir(path, mode) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = formatPath(path);
+        const stats = yield fs.promises.lstat(path);
+        if (stats.isDirectory()) {
+            return true;
+        }
+        try {
+            yield fs.promises.mkdir(path, {
+                'recursive': true,
+                'mode': mode
+            });
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+exports.mkdir = mkdir;
+function rmdir(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = formatPath(path);
+        const stats = yield fs.promises.lstat(path);
+        if (!stats.isDirectory()) {
+            return true;
+        }
+        try {
+            yield fs.promises.rmdir(path);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+exports.rmdir = rmdir;
+function chmod(path, mod) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = formatPath(path);
+        try {
+            yield fs.promises.chmod(path, mod);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+exports.chmod = chmod;
+function rename(oldPath, newPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        oldPath = formatPath(oldPath);
+        newPath = formatPath(newPath);
+        try {
+            yield fs.promises.rename(oldPath, newPath);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+exports.rename = rename;
+function readDir(path, encoding) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const list = [];
+            if (platform === 'win32') {
+                if (path === '/') {
+                    for (const item of drives) {
+                        list.push({
+                            isFile: false,
+                            isDirectory: true,
+                            isSymbolicLink: false,
+                            'name': item
+                        });
+                    }
+                    return list;
+                }
+                else {
+                    path = path[1] + ':' + path.slice(2);
+                }
+            }
+            const dlist = yield fs.promises.readdir(path, {
+                'encoding': encoding,
+                'withFileTypes': true
+            });
+            for (const item of dlist) {
+                if (item.name === '.' || item.name === '..') {
+                    continue;
+                }
+                list.push({
+                    isFile: item.isFile(),
+                    isDirectory: item.isDirectory(),
+                    isSymbolicLink: item.isSymbolicLink(),
+                    'name': item.name
+                });
+            }
+            return list;
+        }
+        catch (_a) {
+            return [];
+        }
+    });
+}
+exports.readDir = readDir;
+function copyFile(src, dest) {
+    return __awaiter(this, void 0, void 0, function* () {
+        src = formatPath(src);
+        dest = formatPath(dest);
+        try {
+            yield fs.promises.copyFile(src, dest);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+exports.copyFile = copyFile;

package/dist/lib/fs.ts

@@ -0,0 +1,284 @@
+import * as fs from 'fs';
+import * as tool from './tool';
+
+/** --- 当前系统平台 --- */
+const platform: NodeJS.Platform = process.platform;
+
+/** --- path 要额外处理一下，因为 windows 下可能有点不一样 --- */
+function formatPath(path: string): string {
+    if (platform !== 'win32') {
+        return path;
+    }
+    if (path === '/') {
+        return path;
+    }
+    return path[1] + ':' + path.slice(2);
+}
+
+/** --- windows 下驱动器列表 --- */
+const drives: string[] = [];
+
+/** --- 更新 drives 列表 --- */
+export async function refreshDrives(): Promise<void> {
+    if (platform !== 'win32') {
+        return;
+    }
+    drives.length = 0;
+    for (let i = 0; i < 26; ++i) {
+        const char = String.fromCharCode(97 + i);
+        try {
+            await fs.promises.stat(char + ':/');
+            drives.push(char);
+        }
+        catch {
+            // --- 无所谓 ---
+        }
+    }
+}
+
+export async function getContent(
+    path: string,
+    options: {
+        'encoding'?: BufferEncoding;
+        'start'?: number;
+        'end'?: number;
+    }
+): Promise<string | Buffer | null> {
+    path = formatPath(path);
+    const encoding = options.encoding;
+    const start = options.start;
+    const end = options.end;
+    if (start || end) {
+        return new Promise(function(resolve) {
+            const rs = fs.createReadStream(path, {
+                'encoding': encoding,
+                'start': start,
+                'end': end
+            });
+            const data: Buffer[] = [];
+            rs.on('data', function(chunk: Buffer) {
+                data.push(chunk);
+            }).on('end', function() {
+                const buf = Buffer.concat(data);
+                if (encoding) {
+                    resolve(buf.toString());
+                }
+                else {
+                    resolve(buf);
+                }
+            }).on('error', function() {
+                resolve(null);
+            });
+        });
+    }
+    else {
+        try {
+            if (encoding) {
+                return await fs.promises.readFile(path, {
+                    'encoding': encoding
+                });
+            }
+            else {
+                return await fs.promises.readFile(path);
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+}
+
+export async function putContent(path: string, data: string | Buffer, options: {
+    'encoding'?: BufferEncoding;
+    'mode'?: number;
+    'flag'?: string;
+}): Promise<boolean> {
+    path = formatPath(path);
+    try {
+        await fs.promises.writeFile(path, data, options);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export async function readLink(path: string, encoding?: BufferEncoding): Promise<string | null> {
+    path = formatPath(path);
+    try {
+        return await fs.promises.readlink(path, {
+            'encoding': encoding
+        });
+    }
+    catch {
+        return null;
+    }
+}
+
+export async function symlink(filePath: string, linkPath: string, type?: 'dir' | 'file' | 'junction'): Promise<boolean> {
+    filePath = formatPath(filePath);
+    linkPath = formatPath(linkPath);
+    try {
+        await fs.promises.symlink(filePath, linkPath, type);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export async function unlink(path: string): Promise<boolean> {
+    path = formatPath(path);
+    for (let i = 0; i <= 2; ++i) {
+        try {
+            await fs.promises.unlink(path);
+            return true;
+        }
+        catch {
+            await tool.sleep(250);
+        }
+    }
+    try {
+        await fs.promises.unlink(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export async function stats(path: string): Promise<Record<string, any> | null> {
+    path = formatPath(path);
+    try {
+        const item = await fs.promises.lstat(path);
+        return {
+            isFile: item.isFile(),
+            isDirectory: item.isDirectory(),
+            isSymbolicLink: item.isSymbolicLink(),
+            'size': item.size,
+            'blksize': item.blksize,
+            'atimeMs': item.atimeMs,
+            'mtimeMs': item.mtimeMs,
+            'ctimeMs': item.ctimeMs,
+            'birthtimeMs': item.birthtimeMs,
+            'atime': item.atime,
+            'mtime': item.mtime,
+            'ctime': item.ctime,
+            'birthtime': item.birthtime
+        };
+    }
+    catch {
+        return null;
+    }
+}
+
+export async function mkdir(path: string, mode: number): Promise<boolean> {
+    path = formatPath(path);
+    const stats = await fs.promises.lstat(path);
+    if (stats.isDirectory()) {
+        return true;
+    }
+    // --- 深度创建目录 ---
+    try {
+        await fs.promises.mkdir(path, {
+            'recursive': true,
+            'mode': mode
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export async function rmdir(path: string): Promise<boolean> {
+    path = formatPath(path);
+    const stats = await fs.promises.lstat(path);
+    if (!stats.isDirectory()) {
+        return true;
+    }
+    try {
+        await fs.promises.rmdir(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export async function chmod(path: string, mod: string | number): Promise<boolean> {
+    path = formatPath(path);
+    try {
+        await fs.promises.chmod(path, mod);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export async function rename(oldPath: string, newPath: string): Promise<boolean> {
+    oldPath = formatPath(oldPath);
+    newPath = formatPath(newPath);
+    try {
+        await fs.promises.rename(oldPath, newPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export async function readDir(path: string, encoding?: BufferEncoding): Promise<any[]> {
+    try {
+        const list: any[] = [];
+        if (platform === 'win32') {
+            // --- 此处不能用 formatPath，因为还要读 drives ---
+            if (path === '/') {
+                for (const item of drives) {
+                    list.push({
+                        isFile: false,
+                        isDirectory: true,
+                        isSymbolicLink: false,
+                        'name': item
+                    });
+                }
+                return list;
+            }
+            else {
+                path = path[1] + ':' + path.slice(2);
+            }
+        }
+        const dlist = await fs.promises.readdir(path, {
+            'encoding': encoding,
+            'withFileTypes': true
+        });
+        for (const item of dlist) {
+            if (item.name === '.' || item.name === '..') {
+                continue;
+            }
+            list.push({
+                isFile: item.isFile(),
+                isDirectory: item.isDirectory(),
+                isSymbolicLink: item.isSymbolicLink(),
+                'name': item.name
+            });
+        }
+        return list;
+    }
+    catch {
+        return [];
+    }
+}
+
+export async function copyFile(src: string, dest: string): Promise<boolean> {
+    src = formatPath(src);
+    dest = formatPath(dest);
+    try {
+        await fs.promises.copyFile(src, dest);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/tool.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+function sleep(ms) {
+    return new Promise(function (resolve) {
+        setTimeout(function () {
+            resolve();
+        }, ms);
+    });
+}
+exports.sleep = sleep;

package/dist/lib/tool.ts

@@ -0,0 +1,11 @@
+/**
+ * --- 间隔一段时间 ---
+ * @param ms 间隔毫秒
+ */
+export function sleep(ms: number): Promise<void> {
+    return new Promise(function(resolve) {
+        setTimeout(function() {
+            resolve();
+        }, ms);
+    });
+}

package/dist/pre.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron = __importStar(require("electron"));
+electron.contextBridge.exposeInMainWorld('clickgoNative', {
+    invoke: function (name, ...param) {
+        return electron.ipcRenderer.invoke('pre', name, ...param);
+    }
+});

package/dist/pre.ts

@@ -0,0 +1,7 @@
+import * as electron from 'electron';
+
+electron.contextBridge.exposeInMainWorld('clickgoNative', {
+    invoke: function(name: string, ...param: any[]): Promise<void> {
+        return electron.ipcRenderer.invoke('pre', name, ...param);
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clickgo-native",
-  "version": "0.0.1-dev",
+  "version": "0.0.3-dev3",
   "description": "The software developed with ClickGo will run in Windows, Mac OS, Linux.",
   "keywords": [
     "clickgo",
@@ -14,15 +14,14 @@
     "native": "electron ./dist/test"
   },
   "devDependencies": {
-    "@litert/loader": "^3.3.0",
-    "@types/node": "^17.0.45",
-    "@typescript-eslint/eslint-plugin": "^5.30.5",
-    "@typescript-eslint/parser": "^5.30.5",
-    "clickgo": "^3.0.3-dev4",
-    "eslint": "^8.19.0",
-    "typescript": "^4.7.4"
+    "@litert/eslint-plugin-rules": "^0.1.2",
+    "@litert/loader": "^3.4.6",
+    "@types/jszip": "^3.4.1",
+    "@types/node": "^18.11.14",
+    "clickgo": "^3.1.6-dev15",
+    "typescript": "^4.9.4"
   },
   "dependencies": {
-    "electron": "^19.0.8"
+    "electron": "^22.0.2"
   }
 }