clickgo 3.1.1-dev10 → 3.1.3-dev12

package/dist/lib/task.ts

@@ -21,6 +21,7 @@ import * as tool from './tool';
 import * as form from './form';
 import * as control from './control';
 import * as fs from './fs';
+import * as theme from './theme';
 import * as native from './native';
 
 /** --- 当前运行的程序，App 模式下无效 --- */
@@ -29,27 +30,20 @@ export const list: Record<number, types.ITask> = {};
 /** --- 最后一个 task id，App 模式下无效 --- */
 export let lastId: number = 0;
 
-/** --- 当前是否设置的主任务的任务 ID，全局只可设置一次 --- */
-let mainTaskId: number = 0;
+/** --- 当前有焦点的任务 ID --- */
+let focusId: number | null = null;
 
 /**
- * --- 将一个任务设置为主任务，全局只可设置一次 ---
- * @param taskId 任务 ID
+ * --- 设置 task focus id ---
+ * @param id id 或 null
  */
-export function setMain(taskId: number): boolean {
-    if (mainTaskId > 0) {
-        return false;
-    }
-    mainTaskId = taskId;
-    return true;
+export function setFocus(id?: number): void {
+    focusId = id ?? null;
 }
 
-/**
- * --- 判断一个任务 ID 是不是主任务 ---
- * @param taskId 任务 ID
- */
-export function isMain(taskId: number): boolean {
-    return taskId === mainTaskId;
+/** --- 获取当前有焦点的任务 ID --- */
+export function getFocus(): number | null {
+    return focusId;
 }
 
 /** --- task lib 用到的语言包 --- */
@@ -77,7 +71,7 @@ const frameMaps: Record<string, number> = {};
 /**
  * --- 创建 frame 监听，formId 存在则为窗体范围，否则为任务级范围 ---
  * @param fun 监听回调
- * @param opt 选项,count:执行次数，默认无限次,taskId:APP模式下无效,formId:APP模式下无效
+ * @param opt 选项,count:执行次数，默认无限次,formId:限定在当前任务的某个窗体,taskId:APP模式下无效
  */
 export function onFrame(fun: () => void | Promise<void>, opt: {
     'count'?: number;
@@ -190,7 +184,7 @@ export function get(tid: number): types.ITaskInfo | null {
         return null;
     }
     return {
-        'name': list[tid].config.name,
+        'name': list[tid].app.config.name,
         'locale': list[tid].locale.lang,
         'customTheme': list[tid].customTheme,
         'formCount': Object.keys(list[tid].forms).length,
@@ -208,7 +202,7 @@ export function getList(): Record<string, types.ITaskInfo> {
     for (const tid in list) {
         const item = list[tid];
         rtn[tid] = {
-            'name': item.config.name,
+            'name': item.app.config.name,
             'locale': item.locale.lang,
             'customTheme': item.customTheme,
             'formCount': Object.keys(item.forms).length,
@@ -256,33 +250,46 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
         'current': ntask ? ntask.current : undefined,
         'progress': opt.progress
     });
-    if (!app) {
-        // --- fetch 失败，则返回错误，隐藏 notify ---
-        if (notifyId) {
-            setTimeout(function(): void {
-                form.hideNotify(notifyId);
-            }, 2000);
-        }
-        return -1;
-    }
-    if (notifyId && !app.net) {
-        // --- 仅 app 模式隐藏，net 模式还要在 config 当中加载 xml 等非 js 资源文件 ---
+    // --- 无论是否成功，都可以先隐藏 notify 了 ---
+    if (notifyId) {
         setTimeout(function(): void {
             form.hideNotify(notifyId);
         }, 2000);
     }
+    if (!app) {
+        return -1;
+    }
     // --- 申请任务ID ---
     const taskId = ++lastId;
     // --- 注入的参数，屏蔽浏览器全局对象，注入新的对象 ---
     /** --- 不屏蔽的全局对象 --- */
-    const unblock = opt.unblock ?? [];
+    const unblock = opt.unblock ? tool.clone(opt.unblock) : [];
+    const unblockSys = [
+        'require',
+        '__awaiter', 'eval', 'Math', 'Array', 'Blob', 'Error', 'Infinity', 'parseInt', 'parseFloat', 'Promise', 'Date', 'JSON', 'fetch'
+    ];
+    for (const name of unblockSys) {
+        if (unblock.includes(name)) {
+            continue;
+        }
+        unblock.push(name);
+    }
     /** --- 最终注入的对象 --- */
     const invoke: Record<string, any> = {};
     if (!unblock.includes('window')) {
-        invoke.window = undefined;
+        invoke.window = {};
+        for (const name of unblock) {
+            if (window[name] === undefined) {
+                continue;
+            }
+            invoke.window[name] = window[name];
+        }
     }
     const ks = Object.getOwnPropertyNames(window);
     for (const k of ks) {
+        if (k.includes('window')) {
+            continue;
+        }
         if (k.includes('Event')) {
             continue;
         }
@@ -292,11 +299,6 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
         if (/^[0-9]+$/.test(k)) {
             continue;
         }
-        if ([
-            'require',
-            '__awaiter', 'eval', 'Math', 'Array', 'Blob', 'Infinity', 'parseInt', 'parseFloat', 'Promise', 'Date', 'JSON', 'fetch'].includes(k)) {
-            continue;
-        }
         if (unblock.includes(k)) {
             continue;
         }
@@ -347,12 +349,18 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
         getVersion: function(): string {
             return clickgo.getVersion();
         },
-        getNative(): boolean {
-            return clickgo.getNative();
+        isNative(): boolean {
+            return clickgo.isNative();
         },
         getPlatform(): string {
             return clickgo.getPlatform();
         },
+        isImmersion(): boolean {
+            return clickgo.isImmersion();
+        },
+        hasFrame(): boolean {
+            return clickgo.hasFrame();
+        },
         'control': {
             'AbstractControl': class extends control.AbstractControl {
                 public get taskId(): number {
@@ -378,101 +386,109 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
             getCdn: function() {
                 return core.getCdn();
             },
-            initModules: function(names: string | string[]): Promise<number> {
-                return clickgo.core.initModules(names);
-            },
             getModule: function(name: string): null | any {
-                return clickgo.core.getModule(name);
+                return core.getModule(name);
             },
             readApp: function(blob: Blob): Promise<false | types.IApp> {
-                return clickgo.core.readApp(blob);
+                return core.readApp(blob);
             },
             getAvailArea: function(): types.IAvailArea {
-                return clickgo.core.getAvailArea();
+                return core.getAvailArea();
             }
         },
         'dom': {
             setGlobalCursor: function(type?: string): void {
-                clickgo.dom.setGlobalCursor(type);
+                dom.setGlobalCursor(type);
             },
             hasTouchButMouse: function(e: MouseEvent | TouchEvent | PointerEvent): boolean {
-                return clickgo.dom.hasTouchButMouse(e);
+                return dom.hasTouchButMouse(e);
             },
             getStyleCount: function(taskId: number, type: 'theme' | 'control' | 'form'): number {
-                return clickgo.dom.getStyleCount(taskId, type);
-            },
-            getSize: function(el: HTMLElement): types.IDomSize {
-                return clickgo.dom.getSize(el);
+                return dom.getStyleCount(taskId, type);
             },
             watchSize: function(
                 el: HTMLElement,
-                cb: (size: types.IDomSize) => Promise<void> | void,
+                cb: () => void | Promise<void>,
                 immediate: boolean = false
-            ): types.IDomSize {
-                return clickgo.dom.watchSize(el, cb, immediate, taskId);
+            ): boolean {
+                return dom.watchSize(el, cb, immediate, taskId);
             },
             unwatchSize: function(el: HTMLElement): void {
-                clickgo.dom.unwatchSize(el, taskId);
+                dom.unwatchSize(el, taskId);
             },
-            clearWatchSize(): void {
-                clickgo.dom.clearWatchSize(taskId);
+            isWatchSize(el: HTMLElement): boolean {
+                return dom.isWatchSize(el);
             },
             watch: function(el: HTMLElement, cb: () => void, mode: 'child' | 'childsub' | 'style' | 'default' = 'default', immediate: boolean = false): void {
-                clickgo.dom.watch(el, cb, mode, immediate, taskId);
+                dom.watch(el, cb, mode, immediate, taskId);
             },
             unwatch: function(el: HTMLElement): void {
-                clickgo.dom.unwatch(el, taskId);
+                dom.unwatch(el, taskId);
             },
-            clearWatch: function(): void {
-                clickgo.dom.clearWatch(taskId);
+            isWatch(el: HTMLElement): boolean {
+                return dom.isWatch(el);
             },
             watchStyle: function(
                 el: HTMLElement,
                 name: string | string[],
-                cb: (name: string, value: string) => void,
+                cb: (name: string, value: string, old: string) => void,
                 immediate: boolean = false
             ): void {
-                clickgo.dom.watchStyle(el, name, cb, immediate);
+                dom.watchStyle(el, name, cb, immediate);
             },
             isWatchStyle: function(el: HTMLElement): boolean {
-                return clickgo.dom.isWatchStyle(el);
+                return dom.isWatchStyle(el);
+            },
+            watchProperty(
+                el: HTMLElement,
+                name: string | string[],
+                cb: (name: string, value: string) => void,
+                immediate: boolean = false
+            ): void {
+                dom.watchProperty(el, name, cb, immediate);
+            },
+            isWatchProperty(el: HTMLElement): boolean {
+                return dom.isWatchProperty(el);
+            },
+            bindClick(e: MouseEvent | TouchEvent, handler: () => void): void {
+                dom.bindClick(e, handler);
             },
             bindDown: function(oe: MouseEvent | TouchEvent, opt: types.IBindDownOptions) {
-                clickgo.dom.bindDown(oe, opt);
+                dom.bindDown(oe, opt);
             },
-            bindGesture: function(e: MouseEvent | TouchEvent | WheelEvent | { 'x'?: number; 'y'?: number; }, opt: types.IBindGestureOptions): void {
-                clickgo.dom.bindGesture(e, opt);
+            bindGesture: function(oe: MouseEvent | TouchEvent | WheelEvent, before: (e: MouseEvent | TouchEvent | WheelEvent, dir: 'top' | 'right' | 'bottom' | 'left') => boolean, handler: (dir: 'top' | 'right' | 'bottom' | 'left') => void): void {
+                dom.bindGesture(oe, before, handler);
             },
             bindLong: function(
                 e: MouseEvent | TouchEvent,
                 long: (e: MouseEvent | TouchEvent) => void | Promise<void>
             ): void {
-                clickgo.dom.bindLong(e, long);
+                dom.bindLong(e, long);
             },
             bindDrag: function(e: MouseEvent | TouchEvent, opt: { 'el': HTMLElement; 'data'?: any; }): void {
-                clickgo.dom.bindDrag(e, opt);
+                dom.bindDrag(e, opt);
             },
-            'is': clickgo.dom.is,
+            'is': dom.is,
             bindMove: function(e: MouseEvent | TouchEvent, opt: types.IBindMoveOptions): types.IBindMoveResult {
-                return clickgo.dom.bindMove(e, opt);
+                return dom.bindMove(e, opt);
             },
             bindResize: function(e: MouseEvent | TouchEvent, opt: types.IBindResizeOptions): void {
-                clickgo.dom.bindResize(e, opt);
+                dom.bindResize(e, opt);
             },
             findParentByData: function(el: HTMLElement, name: string): HTMLElement | null {
-                return clickgo.dom.findParentByData(el, name);
+                return dom.findParentByData(el, name);
             },
             findParentByClass: function(el: HTMLElement, name: string): HTMLElement | null {
-                return clickgo.dom.findParentByClass(el, name);
+                return dom.findParentByClass(el, name);
             },
             siblings: function(el: HTMLElement): HTMLElement[] {
-                return clickgo.dom.siblings(el);
+                return dom.siblings(el);
             },
             siblingsData: function(el: HTMLElement, name: string): HTMLElement[] {
-                return clickgo.dom.siblingsData(el, name);
+                return dom.siblingsData(el, name);
             },
             fullscreen: function(): boolean {
-                return clickgo.dom.fullscreen();
+                return dom.fullscreen();
             }
         },
         'form': {
@@ -482,76 +498,79 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
                 }
             },
             min: function(fid: number): boolean {
-                return clickgo.form.min(fid);
+                return form.min(fid);
             },
             max: function max(fid: number): boolean {
-                return clickgo.form.max(fid);
+                return form.max(fid);
             },
             close: function(fid: number): boolean {
-                return clickgo.form.close(fid);
+                return form.close(fid);
             },
             bindResize: function(e: MouseEvent | TouchEvent, border: types.TDomBorder): void {
-                clickgo.form.bindResize(e, border);
+                form.bindResize(e, border);
             },
             bindDrag: function(e: MouseEvent | TouchEvent): void {
-                clickgo.form.bindDrag(e);
+                form.bindDrag(e);
             },
             getTaskId: function(fid: number): number {
-                return clickgo.form.getTaskId(fid);
+                return form.getTaskId(fid);
             },
             get: function(fid: number): types.IFormInfo | null {
-                return clickgo.form.get(fid);
+                return form.get(fid);
             },
             getList: function(tid: number): Record<string, types.IFormInfo> {
-                return clickgo.form.getList(tid);
+                return form.getList(tid);
+            },
+            getFocus: function(): number | null {
+                return form.getFocus();
             },
             changeFocus: function(fid: number = 0): void {
-                clickgo.form.changeFocus(fid);
+                form.changeFocus(fid);
             },
             getMaxZIndexID: function(out?: {
                 'taskIds'?: number[];
                 'formIds'?: number[];
             }): number | null {
-                return clickgo.form.getMaxZIndexID(out);
+                return form.getMaxZIndexID(out);
             },
             getRectByBorder: function(border: types.TDomBorder): { 'width': number; 'height': number; 'left': number; 'top': number; } {
-                return clickgo.form.getRectByBorder(border);
+                return form.getRectByBorder(border);
             },
             showCircular: function(x: number, y: number): void {
-                clickgo.form.showCircular(x, y);
+                form.showCircular(x, y);
             },
             moveRectangle: function(border: types.TDomBorder): void {
-                clickgo.form.moveRectangle(border);
+                form.moveRectangle(border);
             },
             showRectangle: function(x: number, y: number, border: types.TDomBorder): void {
-                clickgo.form.showRectangle(x, y, border);
+                form.showRectangle(x, y, border);
             },
             hideRectangle: function(): void {
-                clickgo.form.hideRectangle();
+                form.hideRectangle();
             },
             showDrag: function(): void {
-                clickgo.form.showDrag();
+                form.showDrag();
             },
             moveDrag: function(opt: types.IMoveDragOptions): void {
-                clickgo.form.moveDrag(opt);
+                form.moveDrag(opt);
             },
             hideDrag: function(): void {
-                clickgo.form.hideDrag();
+                form.hideDrag();
             },
             notify: function(opt: types.INotifyOptions): number {
-                return clickgo.form.notify(opt);
+                return form.notify(opt);
             },
             notifyProgress: function(notifyId: number, per: number): void {
-                clickgo.form.notifyProgress(notifyId, per);
+                form.notifyProgress(notifyId, per);
             },
             hideNotify: function(notifyId: number): void {
-                clickgo.form.hideNotify(notifyId);
+                form.hideNotify(notifyId);
             },
             showPop: function(el: HTMLElement, pop: HTMLElement | undefined, direction: 'h' | 'v' | MouseEvent | TouchEvent | { x: number; y: number; }, opt: { 'size'?: { width?: number; height?: number; }; 'null'?: boolean; } = {}): void {
-                clickgo.form.showPop(el, pop, direction, opt);
+                form.showPop(el, pop, direction, opt);
             },
             hidePop: function(pop?: HTMLElement): void {
-                clickgo.form.hidePop(pop);
+                form.hidePop(pop);
             },
             dialog: function(opt: string | types.IFormDialogOptions): Promise<string> {
                 if (typeof opt === 'string') {
@@ -560,7 +579,7 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
                     };
                 }
                 opt.taskId = taskId;
-                return clickgo.form.dialog(opt);
+                return form.dialog(opt);
             },
             confirm: function(opt: string | types.IFormConfirmOptions): Promise<boolean | number> {
                 if (typeof opt === 'string') {
@@ -569,16 +588,16 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
                     };
                 }
                 opt.taskId = taskId;
-                return clickgo.form.confirm(opt);
+                return form.confirm(opt);
             },
             flash: function(fid: number): void {
-                clickgo.form.flash(fid, taskId);
+                form.flash(fid, taskId);
             },
             showLauncher: function(): void {
-                clickgo.form.showLauncher();
+                form.showLauncher();
             },
             hideLauncher: function(): void {
-                clickgo.form.hideLauncher();
+                form.hideLauncher();
             }
         },
         'fs': {
@@ -592,31 +611,31 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.getContent(path, options);
+                return fs.getContent(path, options);
             },
             putContent: function(path: string, data: string | Buffer, options: any = {}) {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.putContent(path, data, options);
+                return fs.putContent(path, data, options);
             },
             readLink: function(path: string, options: any = {}): Promise<string | null> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.readLink(path, options);
+                return fs.readLink(path, options);
             },
             symlink: function(fPath: string, linkPath: string, options: any = {}): Promise<boolean> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.symlink(fPath, linkPath, options);
+                return fs.symlink(fPath, linkPath, options);
             },
             unlink: function(path: string, options: any = {}): Promise<boolean> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.unlink(path, options);
+                return fs.unlink(path, options);
             },
             stats: function(path: string, options: any = {}): Promise<types.IStats | null> {
                 if (!options.files) {
@@ -625,7 +644,7 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.stats(path, options);
+                return fs.stats(path, options);
             },
             isDir: function(path: string, options: any = {}): Promise<types.IStats | false> {
                 if (!options.files) {
@@ -634,7 +653,7 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.isDir(path, options);
+                return fs.isDir(path, options);
             },
             isFile: function(path: string, options: any = {}): Promise<types.IStats | false> {
                 if (!options.files) {
@@ -643,37 +662,37 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.isFile(path, options);
+                return fs.isFile(path, options);
             },
             mkdir: function(path: string, mode?: number, options: any = {}): Promise<boolean> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.mkdir(path, mode, options);
+                return fs.mkdir(path, mode, options);
             },
             rmdir: function(path: string, options: any = {}): Promise<boolean> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.rmdir(path, options);
+                return fs.rmdir(path, options);
             },
             rmdirDeep: function(path: string, options: any = {}): Promise<boolean> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.rmdirDeep(path, options);
+                return fs.rmdirDeep(path, options);
             },
             chmod: function(path: string, mod: string | number, options: any = {}): Promise<boolean> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.chmod(path, mod, options);
+                return fs.chmod(path, mod, options);
             },
             rename(oldPath: string, newPath: string, options: any = {}): Promise<boolean> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.rename(oldPath, newPath, options);
+                return fs.rename(oldPath, newPath, options);
             },
             readDir(path: string, options: any = {}): Promise<types.IDirent[]> {
                 if (!options.files) {
@@ -682,83 +701,123 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.readDir(path, options);
+                return fs.readDir(path, options);
             },
             copyFolder(from: string, to: string, options: any = {}): Promise<number> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.copyFolder(from, to, options);
+                return fs.copyFolder(from, to, options);
             },
             copyFile(src: string, dest: string, options: any = {}): Promise<boolean> {
                 if (!options.current) {
                     options.current = list[taskId].current;
                 }
-                return clickgo.fs.copyFile(src, dest, options);
+                return fs.copyFile(src, dest, options);
             }
         },
         'native': {
-            invoke: function(name: string, ...param: any[]): any {
-                return clickgo.native.invoke(name, ...param);
+            on(
+                name: string,
+                handler: (...param: any[]) => any | Promise<any>,
+                once: boolean = false,
+                formId?: number
+            ): void {
+                native.on(name, handler, once, formId, taskId);
             },
-            max: function(): void {
-                clickgo.native.max();
+            once(
+                name: string,
+                handler: (...param: any[]) => any | Promise<any>,
+                formId?: number
+            ): void {
+                native.once(name, handler, formId, taskId);
+            },
+            off(name: string, formId?: number): void {
+                native.off(name, formId, taskId);
+            },
+            clear(formId?: number, taskId?: number): void {
+                native.clear(formId, taskId);
+            },
+            getListenerList(taskId?: number): Record<string, Record<string, Record<string, number>>> {
+                return native.getListenerList(taskId);
+            },
+            invoke: function(name: string, ...param: any[]): Promise<any> {
+                return native.invoke(name, ...param);
             },
-            min: function(): void {
-                clickgo.native.min();
+            max: async function(): Promise<void> {
+                await native.max();
             },
-            restore: function(): void {
-                clickgo.native.restore();
+            min: async function(): Promise<void> {
+                await native.min();
             },
-            size: function(width: number, height: number): void {
-                clickgo.native.size(width, height);
+            restore: async function(): Promise<void> {
+                await native.restore();
+            },
+            size: async function(width: number, height: number): Promise<void> {
+                await native.size(width, height);
+            },
+            ping: function(val: string): Promise<string> {
+                return native.ping(val);
+            },
+            isMax: function(): Promise<boolean> {
+                return native.isMax();
             }
         },
         'task': {
-            isMain(taskId: number): boolean {
-                return isMain(taskId);
+            getFocus(): number | null {
+                return focusId;
             },
             onFrame: function(fun: () => void | Promise<void>, opt: any = {}): number {
                 opt.taskId = taskId;
-                return clickgo.task.onFrame(fun, opt);
+                return onFrame(fun, opt);
             },
             offFrame: function(ft: number, opt: {
                 'taskId'?: number;
             } = {}): void {
                 opt.taskId = taskId;
-                clickgo.task.offFrame(ft, opt);
+                offFrame(ft, opt);
             },
             get: function(tid: number): types.ITaskInfo | null {
-                return clickgo.task.get(tid);
+                return get(tid);
             },
             getList: function(): Record<string, types.ITaskInfo> {
-                return clickgo.task.getList();
+                return getList();
             },
             run: function(url: string, opt: types.ITaskRunOptions = {}): Promise<number> {
                 opt.taskId = taskId;
-                opt.main = false;
-                return clickgo.task.run(url, opt);
+                if (opt.unblock) {
+                    const inUnblock: string[] = [];
+                    // --- 只能解除屏蔽当前函数里面被解除的变量 ---
+                    for (const item of opt.unblock) {
+                        if (!unblock.includes(item)) {
+                            continue;
+                        }
+                        inUnblock.push(item);
+                    }
+                    opt.unblock = inUnblock;
+                }
+                return run(url, opt);
             },
             end: function(tid: number): boolean {
-                return clickgo.task.end(tid ?? taskId);
+                return end(tid ?? taskId);
             },
             loadLocaleData: function(lang: string, data: Record<string, any>, pre: string = ''): void {
-                clickgo.task.loadLocaleData(lang, data, pre, taskId);
+                loadLocaleData(lang, data, pre, taskId);
             },
             loadLocale: function(lang: string, path: string): Promise<boolean> {
-                return clickgo.task.loadLocale(lang, path, taskId);
+                return loadLocale(lang, path, taskId);
             },
             clearLocale: function(): void {
-                clickgo.task.clearLocale(taskId);
+                clearLocale(taskId);
             },
             setLocale: function(lang: string, path: string): Promise<boolean> {
-                return clickgo.task.setLocale(lang, path, taskId);
+                return setLocale(lang, path, taskId);
             },
             setLocaleLang: function(lang: string): void {
-                clickgo.task.setLocaleLang(lang, taskId);
+                setLocaleLang(lang, taskId);
             },
             clearLocaleLang: function(): void {
-                clickgo.task.clearLocaleLang(taskId);
+                clearLocaleLang(taskId);
             },
             createTimer: function(
                 fun: () => void | Promise<void>,
@@ -766,20 +825,20 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
                 opt: types.ICreateTimerOptions = {}
             ): number {
                 opt.taskId = taskId;
-                return clickgo.task.createTimer(fun, delay, opt);
+                return createTimer(fun, delay, opt);
             },
             removeTimer: function(timer: number): void {
-                clickgo.task.removeTimer(timer, taskId);
+                removeTimer(timer, taskId);
             },
             sleep: function(fun: () => void | Promise<void>, delay: number): number {
-                return clickgo.task.sleep(fun, delay, taskId);
+                return sleep(fun, delay, taskId);
             },
-            systemTaskInfo: clickgo.task.systemTaskInfo,
+            'systemTaskInfo': clickgo.task.systemTaskInfo,
             setSystem: function(fid: number): boolean {
-                return clickgo.task.setSystem(fid, taskId);
+                return setSystem(fid, taskId);
             },
             clearSystem: function(): boolean {
-                return clickgo.task.clearSystem(taskId);
+                return clearSystem(taskId);
             }
         },
         'theme': {
@@ -807,58 +866,67 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
         },
         'tool': {
             blob2ArrayBuffer: function(blob: Blob): Promise<ArrayBuffer> {
-                return clickgo.tool.blob2ArrayBuffer(blob);
+                return tool.blob2ArrayBuffer(blob);
             },
             clone: function(obj: Record<string, any> | any[]): any[] | any {
-                return clickgo.tool.clone(obj);
+                return tool.clone(obj);
             },
             sleep: function(ms: number = 0): Promise<boolean> {
-                return clickgo.tool.sleep(ms);
+                return tool.sleep(ms);
+            },
+            nextFrame(): Promise<void> {
+                return tool.nextFrame();
+            },
+            sleepFrame(count: number): Promise<void> {
+                return tool.sleepFrame(count);
             },
             purify: function(text: string): string {
-                return clickgo.tool.purify(text);
+                return tool.purify(text);
             },
             rand: function(min: number, max: number): number {
-                return clickgo.tool.rand(min, max);
-            },
-            'RANDOM_N': clickgo.tool.RANDOM_N,
-            'RANDOM_U': clickgo.tool.RANDOM_U,
-            'RANDOM_L': clickgo.tool.RANDOM_L,
-            'RANDOM_UN': clickgo.tool.RANDOM_UN,
-            'RANDOM_LN': clickgo.tool.RANDOM_LN,
-            'RANDOM_LU': clickgo.tool.RANDOM_LU,
-            'RANDOM_LUN': clickgo.tool.RANDOM_LUN,
-            'RANDOM_V': clickgo.tool.RANDOM_V,
-            'RANDOM_LUNS': clickgo.tool.RANDOM_LUNS,
-            random: function(length: number = 8, source: string = clickgo.tool.RANDOM_LN, block: string = ''): string {
-                return clickgo.tool.random(length, source, block);
+                return tool.rand(min, max);
+            },
+            'RANDOM_N': tool.RANDOM_N,
+            'RANDOM_U': tool.RANDOM_U,
+            'RANDOM_L': tool.RANDOM_L,
+            'RANDOM_UN': tool.RANDOM_UN,
+            'RANDOM_LN': tool.RANDOM_LN,
+            'RANDOM_LU': tool.RANDOM_LU,
+            'RANDOM_LUN': tool.RANDOM_LUN,
+            'RANDOM_V': tool.RANDOM_V,
+            'RANDOM_LUNS': tool.RANDOM_LUNS,
+            random: function(length: number = 8, source: string = tool.RANDOM_LN, block: string = ''): string {
+                return tool.random(length, source, block);
             },
             getBoolean: function(param: boolean | string | number): boolean {
-                return clickgo.tool.getBoolean(param);
+                return tool.getBoolean(param);
             },
             getNumber: function(param: string | number): number {
-                return clickgo.tool.getNumber(param);
+                return tool.getNumber(param);
+            },
+            getArray(param: string | any[]): any[] {
+                return tool.getArray(param);
             },
             escapeHTML: function(html: string): string {
-                return clickgo.tool.escapeHTML(html);
+                return tool.escapeHTML(html);
             },
             request: function(url: string, opt: types.IRequestOptions): Promise<null | any> {
-                return clickgo.tool.request(url, opt);
+                return tool.request(url, opt);
             },
             parseUrl: function(url: string): ILoaderUrl {
-                return clickgo.tool.parseUrl(url);
+                return tool.parseUrl(url);
             },
             urlResolve: function(from: string, to: string): string {
-                return clickgo.tool.urlResolve(from, to);
+                return tool.urlResolve(from, to);
             },
             blob2Text: function(blob: Blob): Promise<string> {
-                return clickgo.tool.blob2Text(blob);
+                return tool.blob2Text(blob);
             },
             blob2DataUrl: function(blob: Blob): Promise<string> {
-                return clickgo.tool.blob2DataUrl(blob);
+                return tool.blob2DataUrl(blob);
             },
             execCommand: function(ac: string): void {
-                clickgo.tool.execCommand(ac);
+                tool.execCommand(ac);
             }
         },
         'zip': {
@@ -890,12 +958,11 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
     const path = url;
     const lio = path.endsWith('.cga') ? path.lastIndexOf('/') : path.slice(0, -1).lastIndexOf('/');
     const current = path.slice(0, lio);
-    // --- 创建任务对象 task.IRT ---
+    // --- 创建任务对象 ---
     list[taskId] = {
         'id': taskId,
         'app': app,
         // 'class': null,
-        // 'config': {},
         'customTheme': false,
         'locale': clickgo.vue.reactive({
             'lang': '',
@@ -913,6 +980,30 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
         'timers': {},
         'invoke': invoke
     } as any;
+    // --- locale ---
+    if (app.config.locales) {
+        for (let path in app.config.locales) {
+            const locale = app.config.locales[path];
+            if (!path.endsWith('.json')) {
+                path += '.json';
+            }
+            const lcontent = await fs.getContent(path, {
+                'encoding': 'utf8',
+                'files': app.files,
+                'current': current
+            });
+            if (!lcontent) {
+                continue;
+            }
+            try {
+                const data = JSON.parse(lcontent);
+                loadLocaleData(locale, data, '', taskId);
+            }
+            catch {
+                // --- 无所谓 ---
+            }
+        }
+    }
     let expo: any = [];
     try {
         expo = loader.require('/app.js', app.files, {
@@ -935,33 +1026,58 @@ export async function run(url: string, opt: types.ITaskRunOptions = {}): Promise
     }
     // --- 创建 Task 总 style ---
     dom.createToStyleList(taskId);
-    // --- 执行 app ---
-    const appCls: core.AbstractApp = new expo.default();
-    await appCls.main();
-    if (!list[taskId].class) {
-        // --- 创建任务失败，也可能没设置 config，报弹窗错误，清理启动应用并返回错误 ---
-        // --- 结束任务 ---
-        delete list[taskId];
+    // --- 加载 control ---
+    const r = await control.init(taskId, invoke);
+    if (r < 0) {
         dom.removeFromStyleList(taskId);
-        return -4;
+        delete list[taskId];
+        return -400 + r;
+    }
+    // --- 加载 theme ---
+    if (app.config.themes?.length) {
+        for (let path of app.config.themes) {
+            path += '.cgt';
+            path = tool.urlResolve('/', path);
+            const file = await fs.getContent(path, {
+                'files': app.files,
+                'current': current
+            });
+            if (file && typeof file !== 'string') {
+                const th = await theme.read(file);
+                if (th) {
+                    await theme.load(th, taskId);
+                }
+            }
+        }
+    }
+    else {
+        // --- 加载全局主题 ---
+        if (theme.global) {
+            await theme.load(undefined, taskId);
+        }
+    }
+    // --- 加载任务级全局样式 ---
+    if (app.config.style) {
+        const style = await fs.getContent(app.config.style + '.css', {
+            'encoding': 'utf8',
+            'files': app.files,
+            'current': current
+        });
+        if (style) {
+            const r = tool.stylePrepend(style, 'cg-task' + taskId.toString() + '_');
+            dom.pushStyle(taskId, await tool.styleUrl2DataUrl(app.config.style, r.style, app.files));
+        }
     }
     // --- 触发 taskStarted 事件 ---
     core.trigger('taskStarted', taskId);
-    // --- 给 native 发送任务启动成功的消息 ---
+    // --- 第一个任务给 native 发送任务启动成功的消息 ---
     if (taskId === 1) {
-        native.invoke('cg-init', native.getToken());
-    }
-    // --- 提交 sync ---
-    /*
-    if (clickgo.getNative() && opt.sync) {
-        f.vroot.$refs.form.isNativeSync = true;
-        native.invoke('cg-set-size', native.getToken(), f.vroot.$refs.form.widthData, f.vroot.$refs.form.heightData);
-        window.addEventListener('resize', function(): void {
-            f.vroot.$refs.form.setPropData('width', window.innerWidth);
-            f.vroot.$refs.form.setPropData('height', window.innerHeight);
-        });
+        await native.invoke('cg-init', native.getToken());
     }
-    */
+    // --- 执行 app ---
+    const appCls: core.AbstractApp = new expo.default();
+    list[taskId].class = appCls;
+    await appCls.main();
     return taskId;
 }
 
@@ -975,8 +1091,8 @@ export function end(taskId: number): boolean {
         return true;
     }
     // --- 如果是 native 模式 ---
-    if (clickgo.getNative() && isMain(taskId)) {
-        native.invoke('cg-close', native.getToken());
+    if (clickgo.isNative() && (taskId === 1)) {
+        native.invoke('cg-close', native.getToken()) as any;
     }
     // --- 获取最大的 z index 窗体，并让他获取焦点 ---
     const fid = form.getMaxZIndexID({
@@ -990,23 +1106,28 @@ export function end(taskId: number): boolean {
     }
     // --- 移除窗体 list ---
     for (const fid in task.forms) {
+        // --- 结束任务挨个关闭窗体 ---
         const f = task.forms[fid];
-        core.trigger('formRemoved', taskId, f.id, f.vroot.$refs.form.title, f.vroot.$refs.form.iconData);
+        core.trigger('formRemoved', taskId, f.id, f.vroot.$refs.form.title, f.vroot.$refs.form.iconDataUrl);
         try {
             f.vapp.unmount();
         }
         catch (err: any) {
             const msg = `Message: ${err.message}\nTask id: ${task.id}\nForm id: ${fid}\nFunction: task.end, unmount.`;
             form.notify({
-                'title': 'Runtime Error',
+                'title': 'Form Unmount Error',
                 'content': msg,
                 'type': 'danger'
             });
-            console.log('Runtime Error', msg, err);
+            console.log('Form Unmount Error', msg, err);
         }
         f.vapp._container.remove();
+        form.elements.popList.querySelector('[data-form-id="' + f.id.toString() + '"]')?.remove();
+        dom.clearWatchStyle(fid);
+        dom.clearWatchProperty(fid);
     }
-    const flist = document.querySelectorAll('#cg-form-list > [data-task-id="' + taskId.toString() + '"]');
+    // --- 移除可能残留的 form wrap ---
+    const flist = form.elements.list.querySelectorAll('.cg-form-wrap[data-task-id="' + taskId.toString() + '"]');
     for (const f of flist) {
         f.remove();
     }
@@ -1025,6 +1146,8 @@ export function end(taskId: number): boolean {
     }
     // --- 移除各类监听 ---
     dom.clearWatchSize(taskId);
+    dom.clearWatch(taskId);
+    native.clear(undefined, taskId);
     // --- 移除 task ---
     delete list[taskId];
     // --- 触发 taskEnded 事件 ---