aview-app 1.0.2

package/aardio/project/aview/res/index.ts

@@ -0,0 +1,1116 @@
+/**
+ * aview
+ */
+
+const aardio = window.chrome.webview.hostObjects.aardio;
+const aardios = window.chrome.webview.hostObjects.sync.aardio;
+
+
+
+const stringToArrayBuffer = (str: string) => {
+    var array = new Uint8Array(str.length);
+    for (var i = 0; i < str.length; i++) {
+        array[i] = str.charCodeAt(i);
+    }
+    return array.buffer
+}
+
+const arrayBufferToArray = (buffer: ArrayBuffer) => {
+    return Array.from(new Uint8Array(buffer));
+}
+
+const ArrayToArrayBuffer = (array: Array<number>) => {
+    return new Int8Array(array).buffer
+}
+
+const arrayBufferToString = (buffer: ArrayBuffer) => {
+    return String.fromCharCode.apply(null, arrayBufferToArray(buffer));
+}
+
+const arrayToObject = (array: Array<any>) => {
+    let arr = array.map((v, i) => {
+        if (Array.isArray(v)) {
+            v = arrayToObject(v);
+        }
+        return v
+    });
+    return Object.assign({}, arr);
+}
+
+const objectToTable = (obj: any) => {
+    return {
+        json: JSON.stringify(obj).replace(/,null/g, "_Function"),//
+        data: Array.isArray(obj) ? arrayToObject(obj) : obj,//如果是数组需要转为对象
+    }
+}
+
+const process = () => {
+    const process: Process = function (pid: any, parameters: any, startInfo: any, ...arg: any) {
+        if (typeof parameters == "object") {
+            parameters = { toJson: JSON.stringify(parameters) };
+        }
+        return aardios.process(pid, parameters, startInfo, ...arg);
+    }
+
+    process.openUrl = (url: string) => {
+        return aardios.process_.openUrl(url);
+    }
+
+    process.exploreSelect = (filePath: string) => {
+        return aardios.process_.exploreSelect(filePath);
+    }
+
+    process.explore = (dirPath: string) => {
+        return aardios.process_.explore(dirPath);
+    }
+
+    process.isExe = (filePath: string) => {
+        return aardios.process_.isExe(filePath);
+    }
+
+    process.kill = null;
+
+    process.getId = () => {
+        return aardios.process_.getId();
+    }
+
+    process.getParentId = () => {
+        return aardios.process_.getParentId();
+    }
+
+    process.popen = new Proxy(aardios.process_.popen2, {
+        get(target, property, receiver) {
+            return aardios.process_.popen_[property]
+        }
+    });
+
+    const popen = function () {
+        let popen: Process["popen"] = function (exefile: any, parameters: any, startInfo: any, ...arg: any) {
+            if (typeof parameters == "object") {
+                parameters = { toJson: JSON.stringify(parameters) };
+            }
+            return aardios.process_.popen2(...arguments);
+
+        }
+
+        popen.cmd = function () {
+            return;
+        }
+
+        return popen;
+    }
+    process.popen = popen();
+
+    return process;
+}
+
+const menu = function (menuObj: any) {
+    if (!menuObj) return menuObj;
+    return new Proxy(menuObj, {
+        get(target, p, receiver) {
+            if (p == "add") {
+                return function (label: any, proc: any) {
+                    return target._add(label, (proc && proc.handlen) || proc)
+                }
+            }
+            if (p == "addTable") {
+                return function (args: any) {
+                    return target._addTable(objectToTable(args));
+                }
+            }
+            return target[p]
+        },
+    })
+}
+
+class Winform extends EventTarget {
+    private _winform;
+    constructor(winform: any) {
+        super();
+        this._winform = winform;
+    }
+    get winform() { return this._winform; }
+
+    get hwnd() {
+        return this._winform.hwnd;
+    }
+    get text() {
+        return this._winform.text;
+    }
+    set text(v) {
+        this._winform.text = v;
+    }
+    get bgcolor() {
+        return this._winform.bgcolor;
+    }
+    set bgcolor(v) {
+        this._winform.bgcolor = v;
+    }
+    get width() {
+        return this._winform.width;
+    }
+    set width(v) {
+        this._winform.width = v;
+    }
+    get height() {
+        return this._winform.height;
+    }
+    set height(v) {
+        this._winform.height = v;
+    }
+    get top() {
+        return this._winform.top;
+    }
+    set top(v) {
+        this._winform.top = v;
+    }
+    get left() {
+        return this._winform.left;
+    }
+    set left(v) {
+        this._winform.left = v;
+    }
+    get dpiScaleX() {
+        return this._winform.dpiScaleX;
+    }
+    get dpiScaleY() {
+        return this._winform.dpiScaleY;
+    }
+    get menu() {
+        return menu(this._winform.menu);
+    }
+    get restoreFullScreen() {
+        return this._winform.restoreFullScreen;
+    }
+
+    resize(width: number, height: number) {
+        this._winform.resize(width, height);
+    }
+
+    fullScreen(isFullScreen: boolean): boolean {
+        return this._winform.fullscreen(isFullScreen);
+    }
+
+    msgbox(str: string, title: string, style: number, timeout: number) {
+        return this._winform.msgbox(str, title, style, timeout)
+    }
+
+    msgboxErr(str: string, title: string) {
+        return this._winform.msgboxErr(str, title);
+    }
+
+    msgboxTest(str: string, title: string) {
+        return this._winform.msgboxTest(str, title);
+    }
+    isZoomed() {
+        return aardios.win.isZoomed(this.hwnd)
+    }
+    show(flag: boolean | number) {
+        this._winform.show(flag);
+    }
+    hide() {
+        this._winform.show(false);
+    }
+    close() {
+        this._winform.close();
+    }
+    transparent(alpha: number | boolean, color: number) {
+        this._winform.transparent(alpha, color);
+    }
+    center(hwnd?: number) {
+        this._winform.center(hwnd);
+    }
+    hitCaption() {
+        this._winform.hitCaption();
+    }
+    hitMin() {
+        this._winform.hitMin();
+    }
+    hitClose() {
+        this._winform.hitClose();
+    }
+    hitMax() {
+        return this._winform.hitMax();
+    }
+    reghotkey(func: Function, mod: number, vk: number): number {
+        return this._winform._reghotkey(func, mod, vk);
+    }
+    unreghotkey(hotkeyId: number, index: number) {
+        this._winform.unreghotkey(hotkeyId);
+    }
+    setIcon(sicon?: string, licon?: string) {
+        this._winform.setIcon(sicon, licon);
+    }
+    getPos(screen: boolean) {
+        let [x, y, width, height] = this._winform._getPos(screen);
+        return { x, y, width, height }
+    }
+    setPos(x: number, y: number, width: number, height: number, after: number) {
+        this._winform.setPos(x, y, width, height, after);
+    }
+
+
+    tray = null
+};
+
+
+// const winform = (): Winform => {
+//     return {
+//         // _form: aardios.winform,
+//         // add(arr: Array<any>) {
+//         //     return aardios.winform._add(objectToTable(arr));
+//         // },
+//         _eventListener: {},
+//         emitEventListener(type: string, data?: string) {
+//             const callbacks = this._eventListener[type];
+//             let event = { returnValue: null, ...JSON.parse(data || "{}") };
+//             callbacks.forEach(fn => fn(event));
+//             return event.returnValue;
+//         },
+
+//         addEventListener(type: string, listener: (event: Event) => void) {
+//             let callbacks = this._eventListener[type] || [];
+//             callbacks.push(listener);
+//             this._eventListener[type] = callbacks;
+//         },
+
+//         removeEventListener(type: string, listener: (event: Event) => void) {
+//             let callbacks = this._eventListener[type];
+//             this._eventListener[type] = callbacks && callbacks.filter(fn => fn !== listener);
+//         },
+
+//         get hwnd() {
+//             return aardios.winform.hwnd;
+//         },
+
+//         get text() {
+//             return aardios.winform.text;
+//         },
+//         set text(v) {
+//             aardio.winform.text = v;
+//         },
+
+//         get bgcolor() {
+//             return aardios.winform.bgcolor;
+//         },
+//         set bgcolor(v) {
+//             aardio.winform.bgcolor = v;
+//         },
+
+//         get width() {
+//             return aardios.winform.width;
+//         },
+
+//         set width(v) {
+//             aardio.winform.width = v;
+//         },
+
+//         get height() {
+//             return aardios.winform.height;
+//         },
+
+//         set height(v) {
+//             aardio.winform.height = v;
+//         },
+
+//         get top() {
+//             return aardios.winform.top;
+//         },
+
+//         set top(v) {
+//             aardio.winform.top = v;
+//         },
+
+//         get left() {
+//             return aardios.winform.left;
+//         },
+
+//         set left(v) {
+//             aardio.winform.left = v;
+//         },
+
+
+//         get dpiScaleX() {
+//             return aardios.winform.dpiScaleX;
+//         },
+
+//         get dpiScaleY() {
+//             return aardios.winform.dpiScaleY;
+//         },
+
+//         get menu() {
+//             return menu(aardios.winform.menu);
+//         },
+
+//         get restoreFullScreen() {
+//             return aardios.winform.restoreFullScreen;
+//         },
+
+//         tray: null,
+
+//         resize(width: number, height: number) {
+//             aardios.winform.resize(width, height);
+//         },
+
+//         fullScreen(isFullScreen: boolean): boolean {
+//             return aardios.winform.fullscreen(isFullScreen);
+//         },
+
+//         msgbox(str: string, title: string, style: number, timeout: number) {
+//             return aardios.winform.msgbox(str, title, style, timeout)
+//         },
+
+//         msgboxErr(str: string, title: string) {
+//             return aardios.winform.msgboxErr(str, title);
+//         },
+
+//         msgboxTest(str: string, title: string) {
+//             return aardios.winform.msgboxTest(str, title);
+//         },
+
+//         //是否最大化
+//         isZoomed() {
+//             return aardios.win.isZoomed(this.hwnd)
+//         },
+
+//         //显示窗口
+//         show(flag: boolean | number) {
+//             aardios.winform.show(flag);
+//         },
+
+//         //隐藏窗口
+//         hide() {
+//             aardios.winform.show(false);
+//         },
+
+//         //关闭窗口
+//         close() {
+//             aardios.winform.close();
+//         },
+
+//         transparent(alpha: number | boolean, color: number) {
+//             aardios.winform.transparent(alpha, color);
+//         },
+
+//         center(hwnd?: number) {
+//             aardios.winform.center(hwnd);
+//         },
+
+//         hitCaption() {
+
+//             // if (this.isZoomed()) {
+//             //     let { x, y } = window.aview.mouse.getPos();
+//             //     window.aview.win.releaseCapture();
+//             //     this.hitMax();
+//             //     this.setPos(x - (this.width * x / (window.screen.width * window.devicePixelRatio)), 2);
+//             // }
+//             aardios.winform.hitCaption();
+//         },
+
+//         hitMin() {
+//             aardios.winform.hitMin();
+//         },
+
+//         hitClose() {
+//             aardios.winform.hitClose();
+//         },
+
+//         hitMax() {
+//             return aardios.winform.hitMax();
+//         },
+
+//         hotkeyIds: [],
+//         reghotkey(func: Function, mod: number, vk: number): number {
+//             let hotkeyId = aardios.winform._reghotkey(func, mod, vk);
+//             this.hotkeyIds.push(hotkeyId);
+//             return hotkeyId;
+//         },
+
+//         unreghotkey(hotkeyId: number, index: number) {
+//             aardios.winform.unreghotkey(hotkeyId);
+//             if (!index) {
+//                 this.hotkeyIds = this.hotkeyIds.filter((v: number) => v == hotkeyId)
+//             }
+//         },
+//         setIcon(sicon?: string, licon?: string) {
+//             aardios.winform.setIcon(sicon, licon);
+//         },
+
+//         getPos(screen: boolean) {
+//             let [x, y, width, height] = aardios.winform._getPos(screen);
+//             return { x, y, width, height }
+//         },
+
+//         setPos(x: number, y: number, width: number, height: number, after: number) {
+//             aardios.winform.setPos(x, y, width, height, after);
+//         },
+
+//         taskbar: {
+//             //设置进度条，设置为0可隐藏进度条
+//             SetProgressValue: (ullCompleted: number, ullTotal: number) => {
+//                 aardios.winform.taskbar.SetProgressValue(window.aview.winform.hwnd, ullCompleted, ullTotal);
+//             }
+//         }
+
+//     }
+// }
+
+class Webview2 extends EventTarget {
+    private _webview2;
+    constructor(webview2: any) {
+        super();
+        this._webview2 = webview2;
+    }
+
+    get webview2() { return this._webview2; }
+
+    set defaultBackgroundColor(v: number) {
+        this._webview2.defaultBackgroundColor = v;
+    }
+    get defaultBackgroundColor() {
+        return this._webview2.defaultBackgroundColor;
+    }
+    get hwndChrome() {
+        return this._webview2.hwndChrome;
+    }
+    set isVisible(v: boolean) {
+        this._webview2.isVisible = !!v;
+    }
+    get isVisible() {
+        return !!this._webview2.isVisible;
+    }
+
+    /**
+     * Chrome DevTools Protocol
+     * 参考 https://chromedevtools.github.io/devtools-protocol/
+     */
+    cdp(method: string, params: any) {
+        return new Promise((resolve, reject) => {
+            this._webview2._cdp(method, JSON.stringify(params), resolve);
+        });
+    }
+}
+
+// const webview = () => {
+//     return {
+//         set defaultBackgroundColor(v: number) {
+//             aardios.webview.defaultBackgroundColor = v;
+//         },
+//         get defaultBackgroundColor() {
+//             return aardios.webview.defaultBackgroundColor;
+//         },
+
+//         get hwndChrome() {
+//             return aardios.webview.hwndChrome;
+//         },
+
+//         set isVisible(v: boolean) {
+//             aardios.webview.isVisible = !!v;
+//         },
+//         get isVisible() {
+//             return !!aardios.webview.isVisible;
+//         },
+
+//         /**
+//          * Chrome DevTools Protocol
+//          * 参考 https://chromedevtools.github.io/devtools-protocol/
+//          */
+//         cdp(method: string, params: any) {
+//             return new Promise((resolve, reject) => {
+//                 aardios.webview._cdp(method, JSON.stringify(params), resolve);
+//             });
+//         },
+//     }
+// }
+
+const win = () => {
+    return {
+        //释放鼠标捕获，成功true
+        releaseCapture: aardios.win.releaseCapture,
+
+        ui: {
+            shadow: aardios.win.ui._shadow,
+            minmax: aardios.win.ui._minmax,
+            menu() {
+                return menu(aardios.win.ui.menu2(...arguments));
+            },
+            popmenu() {
+                return menu(aardios.win.ui.popmenu2(...arguments));
+            },
+        },
+
+        util: {
+            tray() {
+                window.aview.winform.tray = aardios.win.util._tray(...arguments);
+                return window.aview.winform.tray;
+            },
+        },
+
+        //剪贴板，js 中 navigator.clipboard
+        clip: {
+
+            read() {
+                return aardios.win.clip.read()
+            },
+
+            write(str: string) {
+                return aardios.win.clip.write(str)
+            },
+
+            file: {
+                /**
+                 * 返回剪贴板文件路径数组
+                 */
+                read() {
+                    let res = aardios.win.clip.file._read()
+                    let files = JSON.parse(res[0]);
+                    files.effect = res[1];
+                    return files;
+                },
+                /**
+                 * 将文件复制到剪贴板
+                 * @1可用字符串或字符串数组指定一个或多个文件路径
+                 * 可选使用参数@3指定在复制前是否清空剪贴板,默认清空
+                 * 可选使用参数@3指定在复制前是否清空剪贴板,默认清空
+                 */
+                write(file: string | Array<string>, effect: string, rep: boolean) {
+                    return aardios.win.clip.file._write(JSON.stringify(file), effect, rep);
+                }
+
+            },
+            gif: {
+                /**
+                 * 复制 GIF 动画到剪贴板,
+                 * 参数指定*.gif 文件路径
+                 * 剪贴板虽没有 GIF 专有格式,但是这个函数拥有良好的兼容性
+                 */
+                write(path: string) {
+                    return aardios.win.clip.gif.write(path);
+                }
+            },
+            html: {
+                /**
+                * 返回剪贴板html
+                */
+                read() {
+                    return aardios.win.clip.html_._read();
+                },
+                /**
+                 * 将html复制到剪贴板
+                 */
+                write(html: string) {
+                    return aardios.win.clip.html_._write(html);
+                }
+            },
+            png: {
+                /**
+                * 返回剪贴板html
+                */
+                read() {
+                    return ArrayToArrayBuffer(aardios.win.clip.png._read());
+                },
+                /**
+                 * 将html复制到剪贴板
+                 */
+                write(buffer: ArrayBuffer) {
+                    return aardios.win.clip.png._write(JSON.stringify({ "data": arrayBufferToArray(buffer), "type": "Buffer" }));
+                }
+            }
+        }
+    }
+}
+
+const fsys = () => {
+    return {
+        set opFlags(v) {
+            aardios.fsys.opFlags = v;
+        },
+
+        get opFlags() {
+            return aardios.fsys.opFlags;
+        },
+
+        get opError() {
+            return aardios.fsys.opError;
+        },
+
+        createDir(dir: string, clear: boolean) {
+            return new Promise((resolve, reject) => aardios.fsys._createDir(dir, clear, resolve, reject))
+        },
+        searchFile(filename: string, dir: string) {
+            return new Promise((resolve, reject) => aardios.fsys._searchFile(filename, dir, resolve, reject))
+        },
+        setAttributes(path: string, attr: any) {
+            return aardios.fsys.setAttributes(path, attr);
+        },
+        getAttributes(path: string) {
+            return aardios.fsys.getAttributes(path);
+        },
+        isDir(path: string) {
+            return aardios.fsys.isDir(path) === 0x10;
+        },
+        isReadonly(path: string) {
+            return aardios.fsys.isReadonly(path) === 0x1;
+        },
+        isSystem(path: string) {
+            return aardios.fsys.isSystem(path) === 0x4;
+        },
+        isHidden(path: string) {
+            return aardios.fsys.isHidden(path) === 0x2;
+        },
+        list(dir: string, pattern: string, wildcard: string) {
+            return new Promise((resolve, reject) => aardios.fsys._list(dir, pattern, wildcard, (data: string) => resolve(JSON.parse(data)), reject))
+        },
+        delete(path: string | Array<string>, flag?: any, title?: string, hwnd?: number) {
+            return new Promise((resolve, reject) => aardios.fsys._delete(path, flag, title, hwnd, resolve, reject))
+        },
+        move(path: string, to: string, flag?: any, title?: string, hwnd?: number) {
+            return new Promise((resolve, reject) => aardios.fsys._move(path, to, flag, title, hwnd, resolve, reject))
+        },
+        copy(path: string, to: string, flag?: any, title?: string, hwnd?: number) {
+            return new Promise((resolve, reject) => aardios.fsys._copy(path, to, flag, title, hwnd, resolve, reject))
+        },
+        rename(path: string, to: string, flag?: any) {
+            return new Promise((resolve, reject) => aardios.fsys._rename(path, to, flag, resolve, reject))
+        },
+        replace(path: string, substr: string, newSubStr: string, number: string) {
+            return new Promise((resolve, reject) => aardios.fsys._replace(path, substr, newSubStr, number, resolve, reject))
+        },
+
+
+        dlg: {
+            openEx(filter?: string, title?: string, initialDir?: string, hwndOwner?: number, flag?: number, bufSize?: number, defFile?: string) {
+                return new Promise((resolve, reject) => aardios.fsys.dlg._openEx(filter, title, initialDir, hwndOwner, flag, bufSize, defFile, resolve, reject))
+            },
+            open(filter?: string, title?: string, initialDir?: string, hwndOwner?: number, flag?: number, defFile?: string) {
+                return new Promise((resolve, reject) => aardios.fsys.dlg._open(filter, title, initialDir, hwndOwner, flag, defFile, resolve, reject))
+            },
+            save(filter?: string, title?: string, initialDir?: string, hwndOwner?: number, flag?: number, defFile?: string) {
+                return new Promise((resolve, reject) => aardios.fsys.dlg._save(filter, title, initialDir, hwndOwner, flag, defFile, resolve, reject))
+            },
+            saveOp(filter?: string, title?: string, initialDir?: string, hwndOwner?: number, defFile?: string) {
+                return this.save(filter, title, initialDir, hwndOwner, 2, defFile);
+            },
+            dir(path?: string, hwndOwner?: number, title?: string, okLabel?: string, clientGuid?: string, multiSel?: boolean) {
+                return new Promise((resolve, reject) => aardios.fsys.dlg._dir(path, hwndOwner, title, okLabel, clientGuid, multiSel, resolve, reject))
+            },
+        },
+
+        file(path: string, mode = "r", sharemode = 3, creation = 3, flagsAndAttributes: any, secAttrib: any, template: any) {
+            const file = aardios.fsys.file2(path, mode, sharemode, creation, flagsAndAttributes, secAttrib, template);
+            return {
+                get path() {
+                    return file.path;
+                },
+                readTo(ends: string) {
+                    return new Promise((resolve, reject) => file._readTo(ends, resolve, reject));
+                },
+                read(len?: number) {
+                    return new Promise((resolve, reject) => file._read(len, resolve, reject));
+                },
+                readAll() {
+                    return new Promise((resolve, reject) => file._readAll(resolve, reject));
+                },
+                write(str: string | number) {
+                    return new Promise((resolve, reject) => file._write(str, resolve, reject));
+                },
+                // readBuffer() {
+                //     return new Promise((resolve, reject) => file._readBuffer((buf: any) => resolve(buf && ArrayToArrayBuffer(buf.data)), reject));
+                // },
+                // writeBuffer(buf: ArrayBuffer) {
+                //     return new Promise((resolve, reject) => file._writeBuffer(JSON.stringify({ type: "Buffer", data: arrayBufferToArray(buf) }), resolve, reject));
+                // },
+                seek(mode: string, off: number) {
+                    return file.seek(mode, off)
+                },
+                flush() {
+                    return file.flush()
+                },
+                delete() {
+                    return file.delete()
+                },
+                close() {
+                    return file.close()
+                },
+                seteof() {
+                    return file.seteof()
+                },
+                size() {
+                    return file.size()
+                },
+                // setTime
+                // getTime
+            }
+        }
+
+    }
+}
+
+const key = () => {
+    return {
+        hotkey: aardios.key.hotkey2
+    }
+}
+
+const web = () => {
+    return {
+        view(winform: any, config: any) {
+            //winform如果为空则新建一个子窗口
+            return aardios.web.view(winform, config);
+        },
+        aview() {
+            // return aardios.web.aview();
+        }
+    }
+}
+
+const inet = () => {
+    return {
+        /**
+         * 用于获取网络连接信息
+         * sys.networkCards 取的是网卡信息,包含禁用的网卡,
+         * 而 inet.adapter 取的启用的网络连接信息,也就是 IP 配置这些。
+         * 使用 com.wmi  查询 Win32_NetworkAdapter 得到的是网卡信息,
+         * com.wmi 查询 Win32_NetworkAdapterConfiguration 得到的是连接信息。
+         * @returns Array
+         */
+        adapter() {
+            return JSON.parse(aardios.inet.adapter.get());
+        },
+
+        /**
+         * 创建一个下载对话框
+         * @param parent 父窗口
+         * @param title 标题
+         * @param closeTimeout 超时时间
+         * @returns 
+         */
+        downBox(parent: number, title: string, closeTimeout: number) {
+            return aardios.inet.downBox(parent, title, closeTimeout);
+        },
+
+        ftp: null,
+
+        http: {
+            /**
+             * 用于界面线程创建线程并获取 @url 指定网址的数据,
+             * 此函数等待下载完成但不会阻塞界面消息循环,
+             * 可选用 @headers 指定 HTTP 头,
+             * 可选用 @referer 指定引用网址,
+             * 所有参数用法与 格式请参考 inet.http 对象的 get 函数相同
+             * 向服务器发送GET请求并下载服务器返回的数据,
+             * 除URL外,其他为可选参数
+             * @param url 
+             * @param headers 
+             * @param referer 
+             * @returns 本地内部错误返回值为:null,错误信息,错误代码,服务端返回HTTP错误时返回值为:false,错误信息,HTTP错误代码,成功返回字符串对象
+             */
+            get(url: string, headers: string, referer: string) {
+                return aardios.inet.http_.get(url, headers, referer);
+            },
+
+            /**
+             * 当前是否能正常访问互联网
+             */
+            isAlive() {
+                return aardios.inet.http_.isAlive();
+            },
+        },
+
+        /**
+         * 下载文件,支持断点续传
+         * @param url 
+         * @param path 
+         * @param resumePath
+         */
+        httpFile(url: string, path: string, resumePath: string) {
+            return aardios.inet.httpFile(url, path, resumePath);
+        },
+
+        mac: {
+            /**
+             * 返回硬件MAC - OID_802_3_PERMANENT_ADDRESS
+             */
+            getPermanentAddress(id: string) {
+                return aardios.inet.mac.getPermanentAddress(id);
+            },
+
+            /**
+             * 返回当前联网目标主机的网卡的MAC地址
+             * @param host 
+             * @param port 
+             */
+            getAddress(host: string, port: number) {
+                return aardios.inet.mac.getAddress(host, port);
+            },
+        }
+    }
+}
+
+
+const mouse = () => {
+    return {
+        getPos() {
+            let [x, y] = aardios.mouse._getPos();
+            return { x, y };
+        },
+
+        setPos(x: number, y: number) {
+            return aardios.mouse.setPos(x, y);
+        },
+
+        //屏幕选区工具
+        screenArea: () => {
+            return new Promise((resolve) => {
+                let screenArea = aardios.mouse.screenAreas((buf: any) => {
+                    resolve(ArrayToArrayBuffer(buf.data))
+                });
+                screenArea.doModal()
+            })
+        },
+    }
+}
+
+const sys = () => {
+    return {
+        //关机
+        shutdown() {
+            return aardios.sys.shutdown();
+        },
+
+        //重启
+        restart() {
+            return aardios.sys.restart();
+        },
+
+        //注销
+        logoff() {
+            return aardios.sys.logoff();
+        },
+
+        //睡眠，即硬盘休眠+内存待机
+        sleep() {
+            return aardios.sys.sleep();
+        },
+
+        //休眠
+        hibernate() {
+            return aardios.sys.hibernate();
+        },
+
+        //锁定计算机
+        lock() {
+            return aardios.sys.lock();
+        },
+
+        //返回当前登录用户名
+        getUserName() {
+            return aardios.sys.getUserName();
+        },
+
+        //返回计算机名
+        getComputerName() {
+            return aardios.sys.getComputerName();
+        },
+
+        //修改计算机名,重启后生效
+        setComputerName(name: string) {
+            return aardios.sys.setComputerName(name);
+        },
+
+        //返回系统启动时间
+        getStartTime() {
+            // return aardios.sys.getStartTime();
+        },
+
+        //系统音量控制
+        audioVolume: {
+            get volume() {
+                return aardios.sys._audioVolume.volume
+            },
+            set volume(v: number) {
+                aardios.sys._audioVolume.volume = v
+            },
+            get mute() {
+                return aardios.sys._audioVolume.mute
+            },
+            set mute(m: boolean) {
+                aardios.sys._audioVolume.mute = m
+            },
+        },
+
+        //主板信息
+        baseBoard: aardios.sys.baseBoard,
+
+        //处理器信息
+        cpu: aardios.sys.cpu,
+
+        //显卡
+        display: null,
+
+        //内存信息
+        mem: {
+            //返回内存信息
+            getInfo() {
+                return aardios.sys.mem.getInfo();
+            }
+        },
+
+        //显示器
+        monitor: null,
+
+        //网卡设备
+        networkCards: null,
+
+        //电源管理
+        power: {
+            /**
+             * 返回表示电源状态的 SYSTEM_POWER_STATUS 结构体
+             * 结构体文档:\nhttps://docs.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-system_power_status
+             */
+            status() {
+                return JSON.parse(aardios.sys.power._status());
+            },
+
+            /**
+             * 当前使用外部电源返回 true
+             * 使用电池返回 false
+             * @returns 
+             */
+            isAcOnline() {
+                return aardios.sys.power.isAcOnline();
+            },
+
+            /**
+             * 调用 powercfg 命令，返回进程输出
+             * @returns 
+             */
+            command() {
+                return aardios.sys.power.command();
+            },
+
+            /**
+             * 设置显示器空闲关闭的超时值，
+             * 参数@1 指定超时，以秒为单位，设为 0 则禁用空闲关屏
+             * @returns 
+             */
+            setMonitorTimeout(s: number) {
+                return aardios.sys.power.setMonitorTimeout(s);
+            },
+
+            /**
+             * 返回显示器空闲关闭的超时值，以秒为单位
+             * @returns 
+             */
+            getMonitorTimeout() {
+                return aardios.sys.power.getMonitorTimeout();
+            },
+
+            /**
+             * 打开电源管理
+             * @returns 
+             */
+            settings() {
+                return aardios.sys.power.settings();
+            },
+        }
+    }
+}
+
+const raw = () => {
+    return {
+        loadDll(path: string) {
+            return aardios.raw._loadDll(path);
+        },
+        tostdcall(callback: Function, struct: string) {
+            return aardios.raw._tostdcall(callback, struct);
+        }
+    }
+}
+
+const io = () => {
+    return aardios.io
+}
+
+const updater = () => {
+    return {
+        /*
+            version参数包含最新版本号，
+            description包含最新版本更新说明，
+            status参数值见下面的列表：
+                "ready": 下载已完成并准备更新,
+                "updated": 已更新到新版本并准备启动新版
+                "complete": 当前已更新并已启动新版本主程序，所有操作已完成
+                "latest": 已经是最新版不需要更新
+                "failed": 出错了,description参数为错误信息
+        
+            这个回调函数不是必须的，
+            在此检测更新代码之前或之后都可以在界面线程调用
+            fsys.update.simpleMain.onStatusChanged 订阅更新状态变更信息。
+            该认阅回调函数的参数与上面的回调参数相同。
+        */
+        onStatusChanged(callback: (version: string, description: string, status: string) => void) {
+            return aardios.fsys.update._simpleMain._onStatusChanged(callback);
+        },
+        checkUpdate(startUpdate: boolean) {
+            return aardios.fsys.update._simpleMain.checkUpdate(startUpdate);
+        },
+        getReadyStatusInfo() {
+            return aardios.fsys.update._simpleMain.getReadyStatusInfo();
+        },
+    }
+}
+
+const com = function () {
+    return {
+        lite() {
+            return aardios.com.lite2(...arguments);
+        }
+    }
+}
+
+class Aview {
+
+    constructor() {
+        
+    }
+
+    //新建aview应用
+    aviewApp(aviewConfig: any) {
+        return aardios.process(aardios.io._exepath, JSON.stringify(aviewConfig));
+    }
+
+    //变量池
+    varpool = aardios.aview.varpool;
+
+    version = aardios.aview.version;
+
+    //引入一个库，并返回这个库的名字空间代理对象，lib
+    import = aardios.import;
+
+    //将字符串转换为代码执行
+    eval = aardios.eval;
+
+    //启动时的配置信息
+    config = JSON.parse(aardios.config);
+    com = com();
+    updater = updater();
+    winform = new Winform(aardios.winform);
+    webview2 = new Webview2(aardios.webview2);
+    fsys = fsys();
+    win = win();
+    key = key();
+    web = web();
+    inet = inet();
+    process = process()
+    mouse = mouse();
+    sys = sys();
+    raw = raw();
+    io = io();
+}
+
+window.aview = new Aview();
+
+console.log("%caview%cv" + window.aview.version, "padding:3px;color:#fff;background:#529BFE;", "padding:3px;color:#fff;background:#49B884;");
+
+window.aardios = aardios;