clickgo 3.16.16 → 3.16.18

package/dist/lib/fs.d.ts

@@ -0,0 +1,35 @@
+import * as types from '../../types';
+export declare function mount(name: string, handler: types.IMountHandler, taskId?: number): boolean;
+export declare function unmount(name: string): Promise<boolean>;
+export declare function getContent(path: string, options?: {
+    'start'?: number;
+    'end'?: number;
+    'progress'?: (loaded: number, total: number) => void | Promise<void>;
+    'cache'?: string;
+}, taskId?: number): Promise<string | Blob | null>;
+export declare function getContent(path: string, options: BufferEncoding | {
+    'encoding': BufferEncoding;
+    'start'?: number;
+    'end'?: number;
+    'progress'?: (loaded: number, total: number) => void | Promise<void>;
+    'cache'?: string;
+}, taskId?: number): Promise<string | null>;
+export declare function putContent(path: string, data: string | Blob, options?: {
+    'encoding'?: BufferEncoding | null;
+    'mode'?: string | number;
+    'flag'?: string | number;
+}, taskId?: number): Promise<boolean>;
+export declare function readLink(path: string, encoding?: BufferEncoding, taskId?: number): Promise<string | null>;
+export declare function symlink(filePath: string, linkPath: string, type?: 'dir' | 'file' | 'junction', taskId?: number): Promise<boolean>;
+export declare function unlink(path: string, taskId?: number): Promise<boolean>;
+export declare function stats(path: string, taskId?: number): Promise<types.IStats | null>;
+export declare function isDir(path: string, taskId?: number): Promise<types.IStats | false>;
+export declare function isFile(path: string, taskId?: number): Promise<types.IStats | false>;
+export declare function mkdir(path: string, mode?: number, taskId?: number): Promise<boolean>;
+export declare function rmdir(path: string, taskId?: number): Promise<boolean>;
+export declare function rmdirDeep(path: string, taskId?: number): Promise<boolean>;
+export declare function chmod(path: string, mod: string | number, taskId?: number): Promise<boolean>;
+export declare function rename(oldPath: string, newPath: string, taskId?: number): Promise<boolean>;
+export declare function readDir(path: string, encoding?: BufferEncoding, taskId?: number): Promise<types.IDirent[]>;
+export declare function copyFolder(from: string, to: string, ignore?: RegExp[], taskId?: number): Promise<number>;
+export declare function copyFile(src: string, dest: string, taskId?: number): Promise<boolean>;

package/dist/lib/fs.js

@@ -153,8 +153,8 @@ function getContent(path, options, taskId) {
                 'encoding': options
             };
         }
-        else if (!options) {
-            options = {};
+        else {
+            options !== null && options !== void 0 ? options : (options = {});
         }
         const encoding = options.encoding;
         const start = options.start;

package/dist/lib/native.d.ts

@@ -0,0 +1,36 @@
+export declare function getToken(): string;
+export declare function on(name: string, handler: (...param: any[]) => any | Promise<any>, once?: boolean, formId?: number, taskId?: number): void;
+export declare function once(name: string, handler: (...param: any[]) => any | Promise<any>, formId?: number, taskId?: number): void;
+export declare function off(name: string, formId?: number, taskId?: number): void;
+export declare function clear(formId?: number, taskId?: number): void;
+export declare function getListenerList(taskId?: number): Record<string, Record<string, Record<string, number>>>;
+export declare function invoke(name: string, ...param: any[]): Promise<any>;
+export declare function quit(): Promise<void>;
+export declare function size(width: number, height: number): Promise<void>;
+export declare function max(): Promise<void>;
+export declare function min(): Promise<void>;
+export declare function restore(): Promise<void>;
+export declare function activate(): Promise<void>;
+export declare function close(): Promise<void>;
+export declare function maximizable(val: boolean): Promise<void>;
+export declare function open(options?: {
+    'path'?: string;
+    'filters'?: Array<{
+        'name': string;
+        'accept': string[];
+    }>;
+    'props'?: {
+        'file'?: boolean;
+        'directory'?: boolean;
+        'multi'?: boolean;
+    };
+}): Promise<string[] | null>;
+export declare function save(options?: {
+    'path'?: string;
+    'filters'?: Array<{
+        'name': string;
+        'accept': string[];
+    }>;
+}): Promise<string | null>;
+export declare function ping(val: string): Promise<string>;
+export declare function isMax(): Promise<boolean>;

package/dist/lib/native.js

@@ -57,6 +57,8 @@ exports.restore = restore;
 exports.activate = activate;
 exports.close = close;
 exports.maximizable = maximizable;
+exports.open = open;
+exports.save = save;
 exports.ping = ping;
 exports.isMax = isMax;
 const clickgo = __importStar(require("../clickgo"));
@@ -204,6 +206,12 @@ function maximizable(val) {
         yield invoke('cg-maximizable', token, val);
     });
 }
+function open(options = {}) {
+    return invoke('cg-form-open', token, options);
+}
+function save(options = {}) {
+    return invoke('cg-form-save', token, options);
+}
 function ping(val) {
     return __awaiter(this, void 0, void 0, function* () {
         return invoke('cg-ping', val);

package/dist/lib/storage.d.ts

@@ -0,0 +1,6 @@
+export declare function get(key: string, taskId?: number): any;
+export declare function set(key: string, val: string | number | any[] | Record<string, any>, taskId?: number): boolean;
+export declare function remove(key: string, taskId?: number): boolean;
+export declare function list(taskId?: number): Record<string, number>;
+export declare function all(): Record<string, number>;
+export declare function clear(path: string): Promise<number>;

package/dist/lib/task.d.ts

@@ -0,0 +1,32 @@
+import * as types from '../../types';
+export declare const list: Record<number, types.ITask>;
+export declare let lastId: number;
+export declare function setFocus(id?: number): void;
+export declare function getFocus(): number | null;
+export declare function onFrame(fun: () => void | Promise<void>, opt?: {
+    'count'?: number;
+    'taskId'?: number;
+    'formId'?: number;
+}): number;
+export declare function offFrame(ft: number, opt?: {
+    'taskId'?: number;
+}): void;
+export declare function get(tid: number): types.ITaskInfo | null;
+export declare function getPermissions(tid: number): string[];
+export declare function getList(): Record<string, types.ITaskInfo>;
+export declare function run(url: string | types.IApp, opt?: types.ITaskRunOptions, ntid?: number): Promise<number>;
+export declare function checkPermission(vals: string | string[], apply?: boolean, applyHandler?: (list: string[]) => void | Promise<void>, taskId?: number): Promise<boolean[]>;
+export declare function end(taskId: number | string): boolean;
+export declare function loadLocaleData(lang: string, data: Record<string, any>, pre?: string, taskId?: number): void;
+export declare function loadLocale(lang: string, path: string, taskId?: number): Promise<boolean>;
+export declare function clearLocale(taskId?: number): void;
+export declare function setLocale(lang: string, path: string, taskId?: number): Promise<boolean>;
+export declare function setLocaleLang(lang: string, taskId?: number): void;
+export declare function clearLocaleLang(taskId?: number): void;
+export declare function createTimer(fun: () => void | Promise<void>, delay: number, opt?: types.ICreateTimerOptions): number;
+export declare function removeTimer(timer: number, taskId?: number): void;
+export declare function sleep(fun: () => void | Promise<void>, delay: number, taskId?: number): number;
+export declare const systemTaskInfo: types.ISystemTaskInfo;
+export declare function setSystem(formId: number, taskId?: number): boolean;
+export declare function clearSystem(taskId?: number | string): boolean;
+export declare function refreshSystemPosition(): void;

package/dist/lib/task.js

@@ -859,7 +859,13 @@ function run(url_1) {
                 },
                 isMax: function () {
                     return native.isMax();
-                }
+                },
+                open: function (options) {
+                    return native.open(options);
+                },
+                save: function (options) {
+                    return native.save(options);
+                },
             },
             'storage': {
                 get: function (key) {

package/dist/lib/theme.d.ts

@@ -0,0 +1,8 @@
+import * as types from '../../types';
+export declare let global: types.ITheme | null;
+export declare function read(blob: Blob): Promise<types.ITheme | false>;
+export declare function load(theme?: types.ITheme, taskId?: number): Promise<boolean>;
+export declare function remove(name: string, taskId?: number): Promise<void>;
+export declare function clear(taskId?: number): Promise<void>;
+export declare function setGlobal(theme: types.ITheme): Promise<void>;
+export declare function clearGlobal(): void;

package/dist/lib/tool.d.ts

@@ -0,0 +1,120 @@
+import * as types from '../../types';
+export declare function compressor<T extends File | Blob>(file: T, options?: {
+    'maxWidth'?: number;
+    'maxHeight'?: number;
+    'quality'?: number;
+}): Promise<File | Blob | false>;
+interface IClassPrototype {
+    'method': Record<string, any>;
+    'access': Record<string, {
+        'get'?: any;
+        'set'?: any;
+    }>;
+}
+export declare function getClassPrototype(obj: object, over?: string[], level?: number): IClassPrototype;
+export declare function blob2ArrayBuffer(blob: Blob): Promise<ArrayBuffer>;
+export declare function sizeFormat(size: number, spliter?: string): string;
+export declare function weightFormat(weight: number, spliter?: string): string;
+export declare function clone(obj: Record<string, any> | any[]): any[] | any;
+export declare function sleep(ms?: number): Promise<boolean>;
+export declare function nextFrame(): Promise<void>;
+export declare function sleepFrame(count: number): Promise<void>;
+export declare function purify(text: string): string;
+export declare function match(str: string, regs: RegExp[]): boolean;
+export declare function styleUrl2DataUrl(path: string, style: string, files: Record<string, Blob | string>): Promise<string>;
+export declare function layoutAddTagClassAndReTagName(layout: string, retagname: boolean): string;
+export declare function layoutInsertAttr(layout: string, insert: string, opt?: {
+    'ignore'?: RegExp[];
+    'include'?: RegExp[];
+}): string;
+export declare function layoutClassPrepend(layout: string, preps: string[]): string;
+export declare function eventsAttrWrap(layout: string): string;
+export declare function teleportGlue(layout: string, formId: number | string): string;
+export declare function stylePrepend(style: string, prep?: string): {
+    'style': string;
+    'prep': string;
+};
+export declare function getMimeByPath(path: string): {
+    'mime': string;
+    'ext': string;
+};
+export declare function rand(min: number, max: number): number;
+export declare const RANDOM_N = "0123456789";
+export declare const RANDOM_U = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export declare const RANDOM_L = "abcdefghijklmnopqrstuvwxyz";
+export declare const RANDOM_UN: string;
+export declare const RANDOM_LN: string;
+export declare const RANDOM_LU: string;
+export declare const RANDOM_LUN: string;
+export declare const RANDOM_V = "ACEFGHJKLMNPRSTWXY34567";
+export declare const RANDOM_LUNS: string;
+export declare function random(length?: number, source?: string, block?: string): string;
+export declare function getBoolean(param: boolean | string | number | undefined): boolean;
+export declare function getNumber(param: string | number): number;
+export declare function getArray(param: string | any[]): any[];
+export declare function escapeHTML(html: string): string;
+export declare function formatColor(color: string): number[];
+export declare function rgb2hex(r: string | number, g?: string | number, b?: string | number, a?: string | number): string;
+export declare function hex2rgb(hex: string): {
+    'r': number;
+    'g': number;
+    'b': number;
+    'a': number;
+    'rgb': string;
+};
+export declare function rgb2hsl(r: string | number, g?: string | number, b?: string | number, a?: string | number, decimal?: boolean): {
+    'h': number;
+    's': number;
+    'l': number;
+    'a': number;
+    'hsl': string;
+};
+export declare function hsl2rgb(h: string | number, s?: string | number, l?: string | number, a?: string | number, decimal?: boolean): {
+    'r': number;
+    'g': number;
+    'b': number;
+    'a': number;
+    'rgb': string;
+};
+export declare function request(url: string, opt: types.IRequestOptions): Promise<null | any>;
+export declare function fetch(url: string, init?: RequestInit): Promise<string | Blob | null>;
+export declare function get(url: string, opt?: {
+    'credentials'?: 'include' | 'same-origin' | 'omit';
+    'headers'?: HeadersInit;
+}): Promise<Response | null>;
+export declare function post(url: string, data: Record<string, any> | FormData, opt?: {
+    'credentials'?: 'include' | 'same-origin' | 'omit';
+    'headers'?: HeadersInit;
+}): Promise<Response | null>;
+export declare function getResponseJson(url: string, opt?: {
+    'credentials'?: 'include' | 'same-origin' | 'omit';
+    'headers'?: HeadersInit;
+}): Promise<any | null>;
+export declare function postResponseJson(url: string, data: Record<string, any> | FormData, opt?: {
+    'credentials'?: 'include' | 'same-origin' | 'omit';
+    'headers'?: HeadersInit;
+}): Promise<any | null>;
+export declare function parseUrl(url: string): ILoaderUrl;
+export declare function urlResolve(from: string, to: string): string;
+export declare function urlAtom(url: string): string;
+export declare function blob2Text(blob: Blob): Promise<string>;
+export declare function blob2DataUrl(blob: Blob): Promise<string>;
+export declare function execCommand(ac: string): void;
+export declare function compar(before: Array<string | number>, after: Array<string | number>): {
+    'remove': Record<string, number>;
+    'add': Record<string, number>;
+    'length': {
+        'remove': number;
+        'add': number;
+    };
+};
+export declare function formatSecond(second: number): string;
+export declare function formatTime(ts: number | Date, tz?: number): {
+    'date': string;
+    'time': string;
+    'zone': string;
+};
+export declare function isMs(time: number): boolean;
+export declare function queryStringify(query: Record<string, any>): string;
+export declare function queryParse(query: string): Record<string, string | string[]>;
+export {};

package/dist/lib/zip.d.ts

@@ -0,0 +1,40 @@
+import jszip from 'jszip';
+import * as types from '../../types';
+export declare class Zip {
+    private readonly _zip;
+    private _path;
+    constructor(zip: jszip);
+    getContent(path: string): Promise<string | null>;
+    getContent<T extends types.TZipOutputType>(path: string, type: T): Promise<types.IZipOutputByType[T] | null>;
+    putContent<T extends types.TZipInputType>(path: string, data: types.IZipInputByType[T], options?: {
+        'base64'?: boolean;
+        'binary'?: boolean;
+        'date'?: Date;
+    }): void;
+    unlink(path: string): void;
+    stats(path: string): types.IZipStats | null;
+    isDir(path: string): types.IZipStats | false;
+    isFile(path: string): types.IZipStats | false;
+    readDir(path?: string, opt?: {
+        'hasChildren'?: boolean;
+        'hasDir'?: boolean;
+        'pathAsKey'?: false;
+    }): types.IZipItem[];
+    readDir(path?: string, opt?: {
+        'hasChildren'?: boolean;
+        'hasDir'?: boolean;
+        'pathAsKey': true;
+    }): Record<string, types.IZipItem>;
+    private _readDir;
+    private _list;
+    private _refreshList;
+    pwd(): string;
+    cd(dir: string): string;
+    generate<T extends types.TZipOutputType>(options?: {
+        'type'?: T;
+        'level'?: number;
+        'onUpdate'?: (percent: number, currentFile: string | null) => void;
+    }): Promise<types.IZipOutputByType[T]>;
+    getList(): Promise<Record<string, Blob | string>>;
+}
+export declare function get(data?: types.TZipInputFileFormat): Promise<Zip | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clickgo",
-  "version": "3.16.16",
+  "version": "3.16.18",
   "description": "Background interface, software interface, mobile phone APP interface operation library.",
   "keywords": [
     "deskrt",
@@ -19,11 +19,13 @@
   },
   "devDependencies": {
     "@litert/eslint-plugin-rules": "^0.3.1",
-    "@litert/loader": "^3.5.8",
-    "@types/node": "^24.0.1",
+    "@types/node": "^24.0.3",
     "electron": "^36.4.0",
-    "jszip": "^3.10.1",
-    "terser": "^5.42.0",
+    "terser": "^5.43.0",
     "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@litert/loader": "^3.5.9",
+    "jszip": "^3.10.1"
   }
 }

package/dist/clickgo.ts

@@ -1,68 +0,0 @@
-/**
- * Copyright 2024 Han Guoshuai <zohegs@gmail.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const version = '3.16.16';
-export function getVersion(): string {
-    return version;
-}
-
-const native = navigator.userAgent.includes('electron') ? true : false;
-export function isNative(): boolean {
-    return native;
-}
-
-let platform: NodeJS.Platform | 'web' = 'web';
-let immersion: boolean = false;
-let frame: boolean = false;
-
-if (native) {
-    const reg = /electron\/(.+?) (.+?)\/(.+?) immersion\/([0-9]) frame\/([0-9])/.exec(navigator.userAgent);
-    if (reg) {
-        platform = reg[2] as any;
-        immersion = reg[4] === '0' ? false : true;
-        frame = reg[5] === '0' ? false : true;
-    }
-}
-export function getPlatform(): NodeJS.Platform | 'web' {
-    return platform;
-}
-
-/**
- * --- 获取当前 native 是否是沉浸式 ---
- */
-export function isImmersion(): boolean {
-    return immersion;
-}
-
-/**
- * --- 是否含有窗体外边框 ---
- */
-export function hasFrame(): boolean {
-    return frame;
-}
-
-export const vue: import('../types/index').IVueObject = (window as any).Vue;
-
-export * as control from './lib/control';
-export * as core from './lib/core';
-export * as dom from './lib/dom';
-export * as form from './lib/form';
-export * as fs from './lib/fs';
-export * as native from './lib/native';
-export * as storage from './lib/storage';
-export * as task from './lib/task';
-export * as theme from './lib/theme';
-export * as tool from './lib/tool';
-export * as zip from './lib/zip';