clickgo 3.16.17 → 3.16.18

package/README.md

@@ -25,7 +25,7 @@ Load the module loader first, and then load it using the module loader.
 **index.html**
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/@litert/loader@3.5.8/dist/loader.min.js?path=index&npm={'clickgo':'3.16.17'}"></script>
+<script src="https://cdn.jsdelivr.net/npm/@litert/loader@3.5.8/dist/loader.min.js?path=index&npm={'clickgo':'3.16.18'}"></script>
 ```
 
 **index.js**

package/dist/app/demo/form/method/native/native.js

@@ -86,5 +86,31 @@ class default_1 extends clickgo.form.AbstractForm {
             yield clickgo.form.dialog((yield clickgo.native.isMax()) ? 'true' : 'false');
         });
     }
+    open() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rtn = yield clickgo.native.open({
+                'filters': [
+                    {
+                        'name': 'Image',
+                        'accept': ['jpg', 'png'],
+                    },
+                ],
+            });
+            yield clickgo.form.dialog(JSON.stringify(rtn));
+        });
+    }
+    save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rtn = yield clickgo.native.save({
+                'filters': [
+                    {
+                        'name': 'Image',
+                        'accept': ['jpg', 'png'],
+                    },
+                ],
+            });
+            yield clickgo.form.dialog(JSON.stringify(rtn));
+        });
+    }
 }
 exports.default = default_1;

package/dist/app/demo/form/method/native/native.xml

@@ -9,5 +9,7 @@
             <button @click="ping">ping("{{val}}")</button>
         </layout>
         <button @click="isMax">isMax</button>
+        <button @click="open">open</button>
+        <button @click="save">save</button>
     </layout>
 </form>

package/dist/clickgo.d.ts

@@ -0,0 +1,17 @@
+export declare function getVersion(): string;
+export declare function isNative(): boolean;
+export declare function getPlatform(): NodeJS.Platform | 'web';
+export declare function isImmersion(): boolean;
+export declare function hasFrame(): boolean;
+export declare const vue: import('../types/index').IVueObject;
+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';

package/dist/clickgo.js

@@ -39,7 +39,7 @@ exports.isNative = isNative;
 exports.getPlatform = getPlatform;
 exports.isImmersion = isImmersion;
 exports.hasFrame = hasFrame;
-const version = '3.16.16';
+const version = '3.16.18';
 function getVersion() {
     return version;
 }

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import * as types from '../types/index';
+export declare let clickgo: typeof import('./clickgo');
+export declare let control: typeof import('./lib/control');
+export declare let core: typeof import('./lib/core');
+export declare let dom: typeof import('./lib/dom');
+export declare let form: typeof import('./lib/form');
+export declare let fs: typeof import('./lib/fs');
+export declare let native: typeof import('./lib/native');
+export declare let storage: typeof import('./lib/storage');
+export declare let task: typeof import('./lib/task');
+export declare let theme: typeof import('./lib/theme');
+export declare let tool: typeof import('./lib/tool');
+export declare let zip: typeof import('./lib/zip');
+export declare let vue: import('../types/index').IVueObject;
+export declare function getVersion(): string;
+export declare function isNative(): boolean;
+export declare function getPlatform(): NodeJS.Platform | 'web';
+export declare function isImmersion(): boolean;
+export declare function hasFrame(): boolean;
+export declare abstract class AbstractBoot {
+    private readonly _debug;
+    isDebug(): boolean;
+    constructor(opt?: {
+        'debug'?: boolean;
+    });
+    abstract main(): void | Promise<void>;
+    onError(taskId: number, formId: number, error: Error, info: string): void | Promise<void>;
+    onScreenResize(): void | Promise<void>;
+    onConfigChanged<T extends types.IConfig, TK extends keyof T>(n: TK, v: T[TK]): void | Promise<void>;
+    onFormCreated(taskId: number, formId: number, title: string, icon: string, showInSystemTask: boolean): void | Promise<void>;
+    onFormRemoved(taskId: number, formId: number, title: string, icon: string): void | Promise<void>;
+    onFormTitleChanged(taskId: number, formId: number, title: string): void | Promise<void>;
+    onFormIconChanged(taskId: number, formId: number, icon: string): void | Promise<void>;
+    onFormStateMinChanged(taskId: number, formId: number, state: boolean): void | Promise<void>;
+    onFormStateMaxChanged(taskId: number, formId: number, state: boolean): void | Promise<void>;
+    onFormShowChanged(taskId: number, formId: number, state: boolean): void | Promise<void>;
+    onFormFocused(taskId: number, formId: number): void | Promise<void>;
+    onFormBlurred(taskId: number, formId: number): void | Promise<void>;
+    onFormFlash(taskId: number, formId: number): void | Promise<void>;
+    onFormShowInSystemTaskChange(taskId: number, formId: number, value: boolean): void | Promise<void>;
+    onFormHashChange(taskId: number, formId: number, value: string, data: Record<string, any>): void | Promise<void>;
+    onTaskStarted(taskId: number): void | Promise<void>;
+    onTaskEnded(taskId: number): void | Promise<void>;
+    onLauncherFolderNameChanged(id: string, name: string): void | Promise<void>;
+    onHashChanged(hash: string): void | Promise<void>;
+    onKeydown(e: KeyboardEvent): void | Promise<void>;
+    onKeyup(e: KeyboardEvent): void | Promise<void>;
+    onRuntimeFileLoad(url: string): void | Promise<void>;
+    onRuntimeFileLoaded(url: string, state: number): void | Promise<void>;
+}
+export declare function launcher(boot: AbstractBoot): void;

package/dist/lib/control.d.ts

@@ -0,0 +1,53 @@
+import * as types from '../../types';
+import * as form from './form';
+export declare abstract class AbstractControl {
+    get filename(): string;
+    get controlName(): string;
+    get taskId(): number;
+    get formId(): number;
+    private _rootForm;
+    get rootForm(): form.AbstractForm & Record<string, any>;
+    private readonly _rootControl;
+    get rootControl(): (AbstractControl & Record<string, any>) | null;
+    get formFocus(): boolean;
+    get path(): string;
+    get prep(): string;
+    get locale(): string;
+    get l(): (key: string, data?: string[]) => string;
+    get classPrepend(): (cla: any) => string;
+    get alignHComp(): string | undefined;
+    get alignVComp(): string | undefined;
+    watch<T extends this & this['props'], TK extends keyof T, TR>(name: TK | (() => TR), cb: (val: T[TK] & TR, old: T[TK] & TR) => void | Promise<void>, opt?: {
+        'immediate'?: boolean;
+        'deep'?: boolean;
+    }): () => void;
+    get refs(): Record<string, HTMLElement & AbstractControl & Record<string, any>>;
+    get nextTick(): () => Promise<void>;
+    allowEvent(e: MouseEvent | TouchEvent | KeyboardEvent): boolean;
+    trigger(name: types.TGlobalEvent, param1?: boolean | Error | string, param2?: string): void;
+    readonly packageFiles: Record<string, Blob | string>;
+    readonly props: {};
+    readonly emits: Record<string, null | ((payload: any) => boolean)>;
+    readonly slots: Record<string, () => any[]>;
+    get slotsAll(): (name: string) => any[];
+    get propBoolean(): (name: keyof this["props"]) => boolean;
+    get propNumber(): (name: keyof this["props"]) => number;
+    get propInt(): (name: keyof this["props"]) => number;
+    get propArray(): (name: keyof this["props"]) => any[];
+    get element(): HTMLElement;
+    emit(name: string, ...v: string | any): void;
+    get parent(): AbstractControl & form.AbstractForm & Record<string, any>;
+    get parentByName(): (controlName: string) => (AbstractControl & Record<string, any>) | null;
+    get parentByAccess(): (name: string, val: string) => (AbstractControl & Record<string, any>) | null;
+    onBeforeCreate(): void | Promise<void>;
+    onCreated(): void | Promise<void>;
+    onBeforeMount(): void | Promise<void>;
+    onMounted(): void | Promise<void>;
+    onBeforeUpdate(): void | Promise<void>;
+    onUpdated(): void | Promise<void>;
+    onBeforeUnmount(): void | Promise<void>;
+    onUnmounted(): void | Promise<void>;
+}
+export declare function read(blob: Blob): Promise<false | types.TControlPackage>;
+export declare function init(taskId: number, invoke: Record<string, any>, cache?: string): Promise<number>;
+export declare function buildComponents(taskId: number, formId: number, path: string): false | Record<string, any>;

package/dist/lib/core.d.ts

@@ -0,0 +1,47 @@
+import * as types from '../../types';
+import * as form from './form';
+export declare const config: types.IConfig;
+export declare const global: any;
+export declare abstract class AbstractApp {
+    get filename(): string;
+    get taskId(): number;
+    set taskId(v: number);
+    abstract main(data: Record<string, any>): Promise<void>;
+    run(form: form.AbstractForm): void;
+    onError(taskId: number, formId: number, error: Error, info: string): void | Promise<void>;
+    onScreenResize(): void | Promise<void>;
+    onConfigChanged<T extends types.IConfig, TK extends keyof T>(n: TK, v: T[TK]): void | Promise<void>;
+    onFormCreated(taskId: number, formId: number, title: string, icon: string, showInSystemTask: boolean): void | Promise<void>;
+    onFormRemoved(taskId: number, formId: number, title: string, icon: string): void | Promise<void>;
+    onFormTitleChanged(taskId: number, formId: number, title: string): void | Promise<void>;
+    onFormIconChanged(taskId: number, formId: number, icon: string): void | Promise<void>;
+    onFormStateMinChanged(taskId: number, formId: number, state: boolean): void | Promise<void>;
+    onFormStateMaxChanged(taskId: number, formId: number, state: boolean): void | Promise<void>;
+    onFormShowChanged(taskId: number, formId: number, state: boolean): void | Promise<void>;
+    onFormFocused(taskId: number, formId: number): void | Promise<void>;
+    onFormBlurred(taskId: number, formId: number): void | Promise<void>;
+    onFormFlash(taskId: number, formId: number): void | Promise<void>;
+    onFormShowInSystemTaskChange(taskId: number, formId: number, value: boolean): void | Promise<void>;
+    onFormHashChange(taskId: number, formId: number, value: string, data: Record<string, any>): void | Promise<void>;
+    onTaskStarted(taskId: number): void | Promise<void>;
+    onTaskEnded(taskId: number): void | Promise<void>;
+    onLauncherFolderNameChanged(id: string, name: string): void | Promise<void>;
+    onHashChanged(hash: string): void | Promise<void>;
+    onKeydown(e: KeyboardEvent): void | Promise<void>;
+    onKeyup(e: KeyboardEvent): void | Promise<void>;
+}
+export declare function getCdn(): string;
+export declare let boot: import('../index').AbstractBoot;
+export declare function regModule(name: string, func: () => any | Promise<any>): boolean;
+export declare function getModule(name: string): Promise<null | any>;
+export declare function trigger(name: types.TGlobalEvent, taskId?: number | string | boolean | KeyboardEvent, formId?: number | string | boolean | Record<string, any> | null, param1?: boolean | Error | string, param2?: string | Record<string, any>, param3?: boolean): void;
+export declare function readApp(blob: Blob): Promise<false | types.IApp>;
+export declare function fetchApp(url: string, opt?: types.ICoreFetchAppOptions, taskId?: number): Promise<null | types.IApp>;
+export declare function getAvailArea(): types.IAvailArea;
+export declare function hash(hash: string, taskId?: number): boolean;
+export declare function getHash(): string;
+export declare function getHost(): string;
+export declare function location(url: string, taskId?: number): boolean;
+export declare function getLocation(): string;
+export declare function back(taskId?: number): boolean;
+export declare function open(url: string): void;

package/dist/lib/dom.d.ts

@@ -0,0 +1,74 @@
+import * as types from '../../types';
+export declare function inPage(el: HTMLElement): boolean;
+export declare const dpi: number;
+export declare function setGlobalCursor(type?: string): void;
+export declare function hasTouchButMouse(e: MouseEvent | TouchEvent | PointerEvent): boolean;
+export declare function createToStyleList(taskId: number): void;
+export declare function removeFromStyleList(taskId: number): void;
+export declare function pushStyle(taskId: number, style: string, type?: 'global' | 'theme' | 'control' | 'form', formId?: number | string, panelId?: number): void;
+export declare function removeStyle(taskId: number, type?: 'global' | 'theme' | 'control' | 'form', formId?: number | string, panelId?: number): void;
+export declare function getStyleCount(taskId: number, type: 'theme' | 'control' | 'form'): number;
+export declare function watchPosition(el: HTMLElement, cb: (state: {
+    'position': boolean;
+    'size': boolean;
+}) => void | Promise<void>, immediate?: boolean): boolean;
+export declare function unwatchPosition(el: HTMLElement): void;
+export declare function isWatchPosition(el: HTMLElement): boolean;
+export declare function clearWatchPosition(formId: number | string, panelId?: number): void;
+export declare function getWatchSizeCount(taskId?: number): number;
+export declare function watchSize(el: HTMLElement, cb: () => void | Promise<void>, immediate?: boolean, taskId?: number): boolean;
+export declare function unwatchSize(el: HTMLElement, taskId?: number): void;
+export declare function isWatchSize(el: HTMLElement): boolean;
+export declare function clearWatchSize(taskId: number): void;
+export declare function getWatchCount(taskId?: number): number;
+export declare function watch(el: HTMLElement, cb: (mutations: MutationRecord[]) => void | Promise<void>, mode?: 'child' | 'childsub' | 'style' | 'text' | 'default', immediate?: boolean, taskId?: number): boolean;
+export declare function unwatch(el: HTMLElement, taskId?: number): void;
+export declare function isWatch(el: HTMLElement): boolean;
+export declare function clearWatch(taskId: number): void;
+export declare function watchStyle(el: HTMLElement, name: string | string[], cb: (name: string, value: string, old: string) => void | Promise<void>, immediate?: boolean): void;
+export declare function isWatchStyle(el: HTMLElement): boolean;
+export declare function clearWatchStyle(formId: number | string, panelId?: number): void;
+export declare function watchProperty(el: HTMLElement, name: string | string[], cb: (name: string, value: any) => void | Promise<void>, immediate?: boolean): void;
+export declare function isWatchProperty(el: HTMLElement): boolean;
+export declare function clearWatchProperty(formId: number | string, panelId?: number): void;
+export declare function getWatchInfo(): types.IGetWatchInfoResult;
+export declare function bindClick(e: MouseEvent | TouchEvent, handler: (e: MouseEvent | TouchEvent, x: number, y: number) => void | Promise<void>): void;
+export declare function bindDblClick(e: MouseEvent | TouchEvent, handler: (e: MouseEvent | TouchEvent, x: number, y: number) => void | Promise<void>): void;
+export declare function bindDown<T extends MouseEvent | TouchEvent>(oe: T, opt: types.IBindDownOptions<T>): void;
+export declare function bindScale(oe: MouseEvent | TouchEvent | WheelEvent, handler: (e: MouseEvent | TouchEvent | WheelEvent, scale: number, cpos: {
+    'x': number;
+    'y': number;
+}) => void | Promise<void>): void;
+export declare function bindGesture(oe: MouseEvent | TouchEvent | WheelEvent, before: (e: MouseEvent | TouchEvent | WheelEvent, dir: 'top' | 'right' | 'bottom' | 'left') => number, handler?: (dir: 'top' | 'right' | 'bottom' | 'left') => void | Promise<void>): void;
+export declare function allowEvent(e: MouseEvent | TouchEvent | KeyboardEvent): boolean;
+export declare function bindLong(e: MouseEvent | TouchEvent, long: (e: MouseEvent | TouchEvent) => void | Promise<void>): void;
+export declare function setDragData(data?: string | number | boolean | Record<string, any>): void;
+export declare function bindDrag(e: MouseEvent | TouchEvent, opt: {
+    'el': HTMLElement;
+    'data'?: any;
+    'start'?: (x: number, y: number) => any;
+    'move'?: (e: MouseEvent | TouchEvent, opt: types.IBindMoveMoveOptions) => void;
+    'end'?: (moveTimes: Array<{
+        'time': number;
+        'ox': number;
+        'oy': number;
+    }>, e: MouseEvent | TouchEvent) => void;
+}): void;
+export declare const is: {
+    move: boolean;
+    shift: boolean;
+    ctrl: boolean;
+    meta: boolean;
+    full: boolean;
+};
+export declare function bindMove(e: MouseEvent | TouchEvent, opt: types.IBindMoveOptions): types.IBindMoveResult;
+export declare function bindResize(e: MouseEvent | TouchEvent, opt: types.IBindResizeOptions): void;
+export declare function findParentByData(el: HTMLElement, name: string, value?: string): HTMLElement | null;
+export declare function findParentByClass(el: HTMLElement, name: string): HTMLElement | null;
+export declare function findParentByTag(el: HTMLElement, name: string): HTMLElement | null;
+export declare function index(el: HTMLElement): number;
+export declare function siblings(el: HTMLElement): HTMLElement[];
+export declare function siblingsData(el: HTMLElement, name: string): HTMLElement[];
+export declare function fullscreen(): Promise<boolean>;
+export declare function exitFullscreen(): Promise<boolean>;
+export declare function createElement<T extends keyof HTMLElementTagNameMap>(tagName: T): HTMLElementTagNameMap[T];

package/dist/lib/form.d.ts

@@ -0,0 +1,222 @@
+import * as types from '../../types';
+import * as control from './control';
+declare abstract class AbstractCommon {
+    get filename(): string;
+    get controlName(): string;
+    set controlName(v: string);
+    get taskId(): number;
+    get formId(): number;
+    set formFocus(b: boolean);
+    get path(): string;
+    get prep(): string;
+    get locale(): string;
+    get l(): (key: string, data?: string[]) => string;
+    get classPrepend(): (cla: any) => string;
+    watch<T extends this, TK extends keyof T, TR>(name: TK | (() => TR), cb: (val: T[TK] & TR, old: T[TK] & TR) => void | Promise<void>, opt?: {
+        'immediate'?: boolean;
+        'deep'?: boolean;
+    }): () => void;
+    get refs(): Record<string, HTMLElement & control.AbstractControl & Record<string, any>>;
+    get nextTick(): () => Promise<void>;
+    allowEvent(e: MouseEvent | TouchEvent | KeyboardEvent): boolean;
+    trigger(name: types.TGlobalEvent, param1?: boolean | Error | string, param2?: string): void;
+    send(fid: number, obj: Record<string, any>): void;
+    onBeforeCreate(): void | Promise<void>;
+    onCreated(): void | Promise<void>;
+    onBeforeMount(): void | Promise<void>;
+    onBeforeUpdate(): void | Promise<void>;
+    onUpdated(): void | Promise<void>;
+    onBeforeUnmount(): void | Promise<void>;
+    onUnmounted(): void | Promise<void>;
+}
+export declare abstract class AbstractPanel extends AbstractCommon {
+    get panelId(): number;
+    get rootForm(): AbstractForm & Record<string, any>;
+    get rootPanel(): control.AbstractControl & Record<string, any>;
+    get formHash(): string;
+    set formHash(fh: string);
+    get formHashData(): Record<string, any>;
+    set formHashData(v: Record<string, any>);
+    formHashBack(): Promise<void>;
+    sendToRootPanel(data: Record<string, any>): void;
+    enterStep(list: Array<{
+        'value': string;
+        'label'?: string;
+        'icon'?: string;
+        'desc'?: string;
+    }>): Promise<boolean>;
+    doneStep(): Promise<void>;
+    qs: Record<string, string>;
+    clearQs(): void;
+    get formFocus(): boolean;
+    onShow(e: types.IAbstractPanelShowEvent): void | Promise<void>;
+    onShowed(): void | Promise<void>;
+    onHide(): void | Promise<void>;
+    onMounted(): void | Promise<void>;
+    onReceive(data: Record<string, any>): void | Promise<void>;
+    onQsChange(): void | Promise<void>;
+    onQsChangeShow(e: types.IAbstractPanelQsChangeShowEvent): void | Promise<void>;
+}
+export declare abstract class AbstractForm extends AbstractCommon {
+    isNativeSync: boolean;
+    isReady: boolean;
+    get formHash(): string;
+    set formHash(v: string);
+    get formHashData(): Record<string, any>;
+    set formHashData(v: Record<string, any>);
+    get topMost(): boolean;
+    set topMost(v: boolean);
+    get bottomMost(): boolean;
+    set bottomMost(v: boolean);
+    get isMask(): boolean;
+    get formFocus(): boolean;
+    get showInSystemTask(): boolean;
+    set showInSystemTask(v: boolean);
+    ready(cb: () => void | Promise<void>): void;
+    formHashBack(): Promise<void>;
+    sendToPanel(panel: control.AbstractControl & Record<string, any>, data: Record<string, any>): void;
+    private _loading;
+    get loading(): boolean;
+    set loading(val: boolean);
+    lockLoading: boolean;
+    private _inStep;
+    get inStep(): boolean;
+    private readonly _stepValues;
+    enterStep(list: Array<{
+        'value': string;
+        'label'?: string;
+        'icon'?: string;
+        'desc'?: string;
+    }>): Promise<boolean>;
+    updateStep(index: number, value: string): boolean;
+    doneStep(): Promise<void>;
+    private _firstShow;
+    show(): void;
+    showDialog(): Promise<string>;
+    hide(): void;
+    close(): void;
+    dialogResult: string;
+    onMounted(data: Record<string, any>): void | Promise<void>;
+    onReceive(data: Record<string, any>): void | Promise<void>;
+    onScreenResize(): void | Promise<void>;
+    onConfigChanged<T extends keyof types.IConfig>(n: keyof types.IConfig, v: types.IConfig[T]): void;
+    onFormCreated(taskId: number, formId: number, title: string, icon: string, showInSystemTask: boolean): void | Promise<void>;
+    onFormRemoved(taskId: number, formId: number, title: string, icon: string): void | Promise<void>;
+    onFormTitleChanged(taskId: number, formId: number, title: string): void | Promise<void>;
+    onFormIconChanged(taskId: number, formId: number, icon: string): void | Promise<void>;
+    onFormStateMinChanged(taskId: number, formId: number, state: boolean): void | Promise<void>;
+    onFormStateMaxChanged(taskId: number, formId: number, state: boolean): void | Promise<void>;
+    onFormShowChanged(taskId: number, formId: number, state: boolean): void | Promise<void>;
+    onFormFocused(taskId: number, formId: number): void | Promise<void>;
+    onFormBlurred(taskId: number, formId: number): void | Promise<void>;
+    onFormFlash(taskId: number, formId: number): void | Promise<void>;
+    onFormShowInSystemTaskChange(taskId: number, formId: number, value: boolean): void | Promise<void>;
+    onFormHashChange(taskId: number, formId: number, value: string, data: Record<string, any>): void | Promise<void>;
+    onTaskStarted(taskId: number): void | Promise<void>;
+    onTaskEnded(taskId: number): void | Promise<void>;
+    onLauncherFolderNameChanged(id: string, name: string): void | Promise<void>;
+    onHashChanged(hash: string): void | Promise<void>;
+    onKeydown(e: KeyboardEvent): void | Promise<void>;
+    onKeyup(e: KeyboardEvent): void | Promise<void>;
+}
+export declare let simpleSystemTaskRoot: types.IVue;
+export declare let launcherRoot: types.IVue;
+export declare const elements: {
+    'wrap': HTMLDivElement;
+    'list': HTMLDivElement;
+    'popList': HTMLDivElement;
+    'circular': HTMLDivElement;
+    'rectangle': HTMLDivElement;
+    'gesture': HTMLDivElement;
+    'drag': HTMLDivElement;
+    'notify': HTMLElement;
+    'alert': HTMLElement;
+    'simpletask': HTMLDivElement;
+    'launcher': HTMLDivElement;
+    'confirm': HTMLDivElement;
+    'init': () => void;
+};
+export declare function superConfirm(html: string): Promise<boolean>;
+export declare function min(formId: number): boolean;
+export declare function max(formId: number): boolean;
+export declare function close(formId: number): boolean;
+export declare function bindResize(e: MouseEvent | TouchEvent, border: types.TDomBorder): void;
+export declare function bindDrag(e: MouseEvent | TouchEvent): void;
+export declare function refreshMaxPosition(): void;
+export declare function getTaskId(formId: number): number;
+export declare function get(formId: number): types.IFormInfo | null;
+export declare function send(formId: number, obj: Record<string, any>): void;
+export declare function getList(taskId: number): Record<string, types.IFormInfo>;
+export declare function getFocus(): number | null;
+export declare const activePanels: Record<string, number[]>;
+export declare function getActivePanel(formId: number): number[];
+export declare function removeActivePanel(panelId: number, formId: number, taskId?: number): boolean;
+export declare function setActivePanel(panelId: number, formId: number, taskId?: number): boolean;
+export declare function hash(hash: string, formId: number): boolean;
+export declare function getHash(formId: number): string;
+export declare function hashBack(formId: number): Promise<boolean>;
+export declare function changeFocus(formId?: number | string): void;
+export declare function getMaxZIndexID(out?: {
+    'taskIds'?: number[];
+    'formIds'?: number[];
+}): number | null;
+export declare function getRectByBorder(border: types.TDomBorderCustom): {
+    'width': number;
+    'height': number;
+    'left': number;
+    'top': number;
+};
+export declare function showCircular(x: number, y: number): void;
+export declare function moveRectangle(border: types.TDomBorderCustom): void;
+export declare function showRectangle(x: number, y: number, border: types.TDomBorderCustom): void;
+export declare function hideRectangle(): void;
+export declare function showDrag(): void;
+export declare function moveDrag(opt: types.IMoveDragOptions): void;
+export declare function hideDrag(): void;
+export declare function alert(content: string, type?: 'default' | 'primary' | 'info' | 'warning' | 'danger'): number;
+export declare function notify(opt: types.INotifyOptions): number;
+export declare function notifyProgress(notifyId: number, per: number): void;
+export declare function notifyContent(notifyId: number, opt: types.INotifyContentOptions): void;
+export declare function hideNotify(notifyId: number): void;
+export declare function appendToPop(el: HTMLElement): void;
+export declare function removeFromPop(el: HTMLElement): void;
+export declare function showPop(el: HTMLElement | types.IVue, pop: HTMLElement | types.IVue | undefined, direction: 'h' | 'v' | 't' | MouseEvent | TouchEvent | {
+    x: number;
+    y: number;
+}, opt?: {
+    'size'?: {
+        width?: number;
+        height?: number;
+    };
+    'null'?: boolean;
+    'autoPosition'?: boolean;
+    'autoScroll'?: boolean;
+    'flow'?: boolean;
+    'way'?: 'normal' | 'click' | 'hover';
+}): void;
+export declare function hidePop(pop?: HTMLElement | types.IVue): void;
+export declare function isJustPop(el: HTMLElement | number): boolean;
+export declare function doFocusAndPopEvent(e: MouseEvent | TouchEvent): void;
+export declare function remove(formId: number): boolean;
+export declare function removePanel(id: number, vapp: types.IVApp, el: HTMLElement): boolean;
+export declare function createPanel<T extends AbstractPanel>(rootPanel: control.AbstractControl, cls: string | (new () => T), opt?: {
+    'layout'?: string;
+    'style'?: string;
+    'path'?: string;
+}, taskId?: number): Promise<{
+    'id': number;
+    'vapp': types.IVApp;
+    'vroot': T;
+}>;
+export declare function create<T extends AbstractForm>(cls: string | (new () => T), data?: Record<string, any>, opt?: {
+    'layout'?: string;
+    'style'?: string;
+    'path'?: string;
+}, taskId?: number): Promise<T>;
+export declare function dialog(opt: string | types.IFormDialogOptions): Promise<string>;
+export declare function confirm(opt: string | types.IFormConfirmOptions): Promise<boolean | number>;
+export declare function prompt(opt: string | types.IFormPromptOptions): Promise<string>;
+export declare function flash(formId: number, taskId?: number): void;
+export declare function showLauncher(): void;
+export declare function hideLauncher(): void;
+export {};

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>;