clickgo 6.8.2 → 6.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clickgo",
-  "version": "6.8.2",
+  "version": "6.9.0",
   "description": "Background interface, software interface, mobile phone APP interface operation library.",
   "type": "module",
   "keywords": [
@@ -20,8 +20,9 @@
     "test:jodit": "node test/jodit-lifecycle.mjs",
     "test:scroll": "node test/scroll.mjs",
     "test:vflow": "node test/vflow.mjs",
-    "test:task": "node test/task-tray.mjs && node test/task-package-loading.mjs",
+    "test:task": "node test/task-tray.mjs && node test/task-start.mjs && node test/task-package-loading.mjs",
     "test:form": "node test/form-viewport.mjs && node --experimental-vm-modules test/form-native.mjs && node test/form-launcher.mjs && node test/form-notify.mjs",
+    "test:notify-animation": "node test/form-notify-animation.mjs",
     "test:native-regions": "node test/form-native-regions.mjs",
     "test:desktop": "node --experimental-vm-modules test/desktop.mjs && node --experimental-vm-modules test/iconview.mjs",
     "test:style": "node --experimental-vm-modules test/dom-style.mjs",

package/test/form-launcher.mjs

@@ -100,3 +100,78 @@ assert.deepEqual(errors, [], 'event handlers do not throw');
 app.unmount();
 dom.window.close();
 console.log('Launcher blank areas, pointer tolerance, drag/cancel, input, folders and single app launch passed.');
+
+// --- 验证实际显示接口及动画时序，重复调用只通知真实状态变更。 ---
+const stateNames = new Set(['launcherShown', 'launcherHideTimer', 'getLauncherShow', 'showLauncher', 'hideLauncher']);
+const stateSource = tree.statements.filter(node => {
+    if (ts.isFunctionDeclaration(node)) return stateNames.has(node.name?.text);
+    return ts.isVariableStatement(node) && node.declarationList.declarations.some(d => stateNames.has(d.name.getText(tree)));
+}).map(node => node.getText(tree)).join('\n');
+const notifications = [];
+const frames = [];
+const timers = new Map();
+let timerId = 0;
+const surface = { style: {}, classList: new Set() };
+surface.classList.remove = surface.classList.delete;
+const launcher = { folderName: 'Folder', name: 'search', closeFolder() { this.folderName = ''; } };
+const stateScope = {
+    exports: {}, elements: { launcher: surface }, launcherRoot: launcher,
+    lCore: { trigger: async (...args) => notifications.push(args) },
+    requestAnimationFrame: callback => frames.push(callback),
+    setTimeout: callback => { timers.set(++timerId, callback); return timerId; },
+    clearTimeout: id => timers.delete(id),
+};
+vm.runInNewContext(ts.transpileModule(stateSource, {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+}).outputText, stateScope);
+const display = stateScope.exports;
+assert.equal(display.getLauncherShow(), false);
+display.hideLauncher();
+display.showLauncher();
+display.showLauncher();
+assert.equal(display.getLauncherShow(), true);
+assert.equal(surface.style.display, 'flex');
+display.hideLauncher();
+frames.splice(0).forEach(callback => callback());
+assert.equal(surface.classList.has('cg-show'), false, 'hide before first paint cannot add a stale visible class');
+display.hideLauncher();
+assert.equal(timers.size, 1, 'duplicate hide does not schedule extra cleanup');
+display.showLauncher();
+assert.equal(timers.size, 0, 'reopening cancels the old closing animation');
+frames.splice(0).forEach(callback => callback());
+assert.equal(surface.classList.has('cg-show'), true);
+assert.equal(launcher.name, 'search', 'cancelled cleanup does not reset the reopened search');
+display.hideLauncher();
+timers.forEach(callback => callback());
+timers.clear();
+assert.equal(surface.style.display, 'none');
+assert.equal(launcher.folderName, '');
+assert.equal(launcher.name, '');
+assert.deepEqual(notifications, [
+    ['launcherShowChanged', true], ['launcherShowChanged', false],
+    ['launcherShowChanged', true], ['launcherShowChanged', false],
+]);
+
+// --- 非 root 应用、自定义任务栏与宿主均接收通知，异步应用不阻塞窗体。 ---
+const coreSource = await readFile(new URL('../dist/lib/core.ts', import.meta.url), 'utf8');
+const coreTree = ts.createSourceFile('core.ts', coreSource, ts.ScriptTarget.ES2022, true);
+const triggerSource = coreTree.statements.find(node => ts.isFunctionDeclaration(node) && node.name?.text === 'trigger').getText(coreTree);
+const delivered = [];
+const routeScope = {
+    exports: {}, sysId: 'system',
+    boot: { onLauncherShowChanged: state => delivered.push(['boot', state]) },
+    lTask: { getOriginList: async () => ({
+        ordinary: { class: { onLauncherShowChanged: state => { delivered.push(['app', state]); return new Promise(() => {}); } },
+            forms: { bar: { vroot: { onLauncherShowChanged: state => delivered.push(['form', state]) } } } },
+    }) },
+};
+vm.runInNewContext(ts.transpileModule(triggerSource, {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+}).outputText, routeScope);
+await routeScope.exports.trigger('launcherShowChanged', true);
+await routeScope.exports.trigger('launcherShowChanged', false);
+assert.deepEqual(delivered, [
+    ['boot', true], ['app', true], ['form', true],
+    ['boot', false], ['app', false], ['form', false],
+]);
+console.log('Launcher state query, broadcast, duplicate calls and close/reopen animation ordering passed.');

package/test/form-notify-animation.mjs

@@ -0,0 +1,102 @@
+// Requires a display; run with npm run test:notify-animation.
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import electron from 'electron';
+import ts from 'typescript';
+
+if (!process.versions.electron) {
+    const child = spawn(electron, [fileURLToPath(import.meta.url), '--ozone-platform=x11'], {
+        'stdio': ['ignore', 'pipe', 'pipe'],
+    });
+    let output = '';
+    child.stdout.on('data', chunk => { output += chunk; });
+    child.stderr.on('data', chunk => { output += chunk; });
+    const timeout = setTimeout(() => child.kill(), 20000);
+    const code = await new Promise(resolve => {
+        child.on('error', error => { output += error.message; resolve(1); });
+        child.on('exit', resolve);
+    });
+    clearTimeout(timeout);
+    assert.equal(code, 0, output);
+    console.log('Notify animation passed: consecutive LTR/RTL entries keep their stacked height and slide horizontally.');
+}
+else {
+    const { app, BrowserWindow } = electron;
+    app.whenReady().then(async () => {
+        const win = new BrowserWindow({
+            'show': false, 'width': 800, 'height': 600,
+            'webPreferences': { 'backgroundThrottling': false, 'offscreen': true },
+        });
+        let exitCode = 0;
+        try {
+            const source = await readFile(new URL('../dist/lib/form.ts', import.meta.url), 'utf8');
+            const start = source.indexOf('let notifyId:');
+            const end = source.indexOf('export function appendToPop', start);
+            const script = ts.transpileModule(source.slice(start, end), {
+                'compilerOptions': { 'module': ts.ModuleKind.CommonJS, 'target': ts.ScriptTarget.ES2022 },
+            }).outputText;
+            const style = await readFile(new URL('../dist/global.css', import.meta.url), 'utf8');
+            await win.loadURL(`data:text/html,${encodeURIComponent(`<style>${style}</style><div id="cg-wrap"><div id="cg-notify"></div></div>`)}`);
+            await win.webContents.executeJavaScript(`
+                window.notifyCore = {
+                    config: { locale: 'en' },
+                    getAvailArea: () => ({ left: 0, top: 0, width: innerWidth, height: innerHeight - 48 }),
+                };
+                window.notifyApi = {};
+                new Function('exports', 'elements', 'lCore', 'lTool', ${JSON.stringify(script)})(
+                    window.notifyApi, { notify: document.getElementById('cg-notify') }, window.notifyCore,
+                    { lang: { getDirection: locale => locale === 'ar' ? 'rtl' : 'ltr' }, escapeHTML: value => value },
+                );
+            `);
+            const traces = await win.webContents.executeJavaScript(`(${recordEntries.toString()})()`);
+            for (const trace of traces) {
+                const label = `${trace.direction} notification ${trace.index + 1}`;
+                assert.ok(trace.samples.every(point => Math.abs(point.y - trace.targetY) < 0.5),
+                    `${label} must enter at its stacked height: ${JSON.stringify(trace)}`);
+                const movement = trace.samples.at(-1).x - trace.samples[0].x;
+                assert.ok(trace.direction === 'ltr' ? movement < -20 : movement > 20,
+                    `${label} must slide in from the outer edge`);
+            }
+        }
+        catch (error) {
+            console.error(error);
+            exitCode = 1;
+        }
+        finally {
+            win.destroy();
+            app.exit(exitCode);
+        }
+    });
+}
+
+/**
+ * --- 在实际渲染帧中记录连续通知的轨迹，避免最终坐标测试漏掉错误的入场方向 ---
+ * @returns LTR/RTL 通知入场的逐帧坐标与目标高度
+ */
+async function recordEntries() {
+    const traces = [];
+    for (const direction of ['ltr', 'rtl']) {
+        document.getElementById('cg-wrap').dir = direction;
+        window.notifyCore.config.locale = direction === 'rtl' ? 'ar' : 'en';
+        for (let index = 0; index < 3; ++index) {
+            const id = window.notifyApi.notify({ 'title': 'Notify', 'content': `Notification ${index}`, 'timeout': 0 });
+            const el = document.querySelector(`[data-notifyid="${id}"]`);
+            const samples = [];
+            for (let frame = 0; frame < 7; ++frame) {
+                await new Promise(resolve => requestAnimationFrame(resolve));
+                const rect = el.getBoundingClientRect();
+                samples.push({ 'x': rect.x, 'y': rect.y });
+            }
+            const target = new DOMMatrix(el.style.transform);
+            traces.push({ direction, index, samples, 'targetY': innerHeight - el.offsetHeight + target.m42 });
+            await Promise.all(el.getAnimations().map(animation => animation.finished));
+        }
+        for (const el of document.querySelectorAll('[data-notifyid]')) {
+            window.notifyApi.hideNotify(Number(el.dataset.notifyid));
+        }
+        await new Promise(resolve => setTimeout(resolve, 150));
+    }
+    return traces;
+}

package/test/rtl-archive.mjs

@@ -22,7 +22,7 @@ const commonControls = new Set([
     'select', 'sidebar-toggle', 'text', 'toolbox',
 ]);
 /** --- 全部内置主题 --- */
-const themes = ['admin', 'cyber', 'dark', 'light', 'modern', 'modern-light', 'software-dark', 'software-light'];
+const themes = ['admin', 'classic', 'cyber', 'dark', 'light', 'modern', 'modern-light', 'software-dark', 'software-light'];
 /** --- CGA 格式常量，与编译器的公开包格式保持一致 --- */
 const cgaHeaderLength = 106;
 const cgaKeyContext = Buffer.from('ClickGo/Application/Package');
@@ -423,6 +423,18 @@ for (const theme of themes) {
         /(?:border|inset|margin|padding)-inline/,
         archiveError(archive, 'style.css has no logical inline-direction properties'),
     );
+    // --- 主题自带图标必须随归档发布，不能只在源码目录中存在。 ---
+    const zip = await loadZipArchive(archive);
+    for (const match of archivedCss.matchAll(/url\(['"]?([^'"\)]+)['"]?\)/g)) {
+        const resource = match[1].replace(/^\.\//, '');
+        if (/^(?:data:|https?:|\/\/|#)/.test(resource)) {
+            continue;
+        }
+        const entry = zip.file(resource);
+        assert.ok(entry, archiveError(archive, `referenced resource ${resource} is absent`));
+        const source = await readProjectFile(`dist/sources/theme/${theme}/${resource}`);
+        assert.deepEqual(await entry.async('nodebuffer'), source, archiveError(archive, `${resource} differs from its source`));
+    }
 }
 
 console.log(`Archive check passed: task.cga has 16 locales, ${localeControls.length} control locale tables are current, and RTL output is present in all ${themes.length} themes.`);

package/test/task-start.mjs

@@ -0,0 +1,141 @@
+import assert from 'node:assert/strict';
+import vm from 'node:vm';
+import { readFile } from 'node:fs/promises';
+import ts from 'typescript';
+import JSZip from 'jszip';
+import { JSDOM } from 'jsdom';
+
+const source = await readFile(new URL('../dist/sources/control/task-start/code.ts', import.meta.url), 'utf8');
+const scope = {
+    exports: {},
+    require: () => ({ control: { AbstractControl: class {
+        propBoolean(name) { return this.props[name] === true || this.props[name] === 'true' || this.props[name] === ''; }
+        parentByName() { return this.taskParent; }
+        watch(name, callback) { this.watched = callback; }
+        emit(name) { this.events.push(name); }
+    } } }),
+};
+vm.runInNewContext(ts.transpileModule(source, {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+}).outputText, scope);
+const start = new scope.exports.default();
+start.events = [];
+let nativeClicks = 0;
+// --- 原生 click 不会触发框架转换后的 tap 监听，键盘必须直接发送控件事件。 ---
+start.element = { click: () => ++nativeClicks };
+const key = (value, extra = {}) => ({ key: value, preventDefault() {}, stopPropagation() {}, ...extra });
+assert.equal(start.labelMode, 'auto');
+start.props.showLabel = 'false';
+assert.equal(start.labelMode, 'hide');
+start.props.showLabel = true;
+assert.equal(start.labelMode, 'show');
+start.taskParent = { position: 'right', mode: 'dock' };
+assert.equal(start.position, 'right');
+assert.equal(start.mode, 'dock');
+start.keydown(key(' '));
+assert.equal(start.isSpaceDown, true);
+assert.equal(start.events.length, 0, 'Space activates on release');
+start.keydown(key(' ', { repeat: true }));
+start.keyup(key(' '));
+start.keyup(key(' '));
+assert.deepEqual(start.events, ['tap']);
+start.props.opened = true;
+start.keydown(key('Enter'));
+start.keydown(key('Enter', { repeat: true }));
+assert.equal(start.events.length, 2, 'held Enter does not repeatedly activate');
+assert.equal(start.props.opened, true, 'activation does not overwrite the caller-owned menu state');
+start.keydown(key('Enter', { isComposing: true }));
+start.onMounted();
+start.keydown(key(' '));
+start.props.disabled = true;
+start.watched();
+assert.equal(start.isSpaceDown, false);
+start.keyup(key(' '));
+start.keydown(key('Enter'));
+start.click({ stopPropagation() {} });
+assert.equal(start.events.length, 2, 'disabled controls never activate');
+assert.equal(nativeClicks, 0, 'keyboard activation does not depend on a native click reaching a tap listener');
+
+// --- 使用真实 Vue、Pointer.js 与框架事件转换，验证 @click 不丢失键盘或重复指针激活。 ---
+const dom = new JSDOM('<!doctype html><html><body><div id="app"></div></body></html>');
+for (const name of ['window', 'document', 'Element', 'HTMLElement', 'SVGElement', 'Node', 'Event', 'CustomEvent']) {
+    Object.defineProperty(globalThis, name, { configurable: true, value: dom.window[name] });
+}
+const vue = await import('vue');
+const pointer = await import('../node_modules/@litert/pointer/dist/index.esm.js');
+const toolSource = await readFile(new URL('../dist/lib/tool.ts', import.meta.url), 'utf8');
+const toolTree = ts.createSourceFile('tool.ts', toolSource, ts.ScriptTarget.ES2022, true);
+const wrapSource = toolTree.statements.find(node => ts.isFunctionDeclaration(node) && node.name?.text === 'eventsAttrWrap').getText(toolTree);
+const toolScope = { exports: {} };
+vm.runInNewContext(ts.transpileModule(wrapSource, {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+}).outputText, toolScope);
+const prepare = layout => toolScope.exports.eventsAttrWrap(layout).replaceAll('@click="', '@tap="');
+const methods = {};
+const computed = {};
+for (const name of Object.getOwnPropertyNames(Object.getPrototypeOf(start))) {
+    if (name === 'constructor') continue;
+    const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(start), name);
+    if (descriptor.value) methods[name] = descriptor.value;
+    else if (descriptor.get) computed[name] = descriptor.get;
+}
+methods.propBoolean = function(name) { return pointerBoolean(this.props[name]); };
+function pointerBoolean(value) { return value === true || value === 'true' || value === ''; }
+methods.parentByName = () => null;
+methods.emit = function(name, event) { this.$emit(name, event); };
+methods.allowEvent = pointer.allowEvent;
+const layout = await readFile(new URL('../dist/sources/control/task-start/layout.html', import.meta.url), 'utf8');
+const component = {
+    template: prepare(layout), props: Object.fromEntries(Object.entries(start.props).map(([name, value]) => [name, { default: value }])),
+    components: { 'cg-img': { template: '<img>' } },
+    emits: start.emits, methods, computed,
+    data: () => ({ isSpaceDown: false, props: {}, element: null }),
+    created() { this.props = this.$props; }, mounted() { this.element = this.$el; },
+};
+const app = vue.createApp({
+    template: prepare('<task-start label="Start" :opened="opened" :disabled="disabled" @click="count++; opened = !opened"></task-start>'),
+    components: { 'task-start': component }, methods: { allowEvent: pointer.allowEvent },
+    data: () => ({ count: 0, opened: false, disabled: false }),
+});
+const root = app.mount('#app');
+const button = document.querySelector('[role="button"]');
+const keyboard = (type, key) => button.dispatchEvent(new window.KeyboardEvent(type, { key, bubbles: true, cancelable: true }));
+keyboard('keydown', 'Enter');
+await vue.nextTick();
+assert.equal(root.count, 1);
+assert.equal(button.getAttribute('aria-expanded'), 'true');
+keyboard('keydown', ' ');
+await vue.nextTick();
+assert.equal(root.count, 1);
+assert.ok(button.classList.contains('active'));
+keyboard('keyup', ' ');
+await vue.nextTick();
+assert.equal(root.count, 2);
+assert.equal(button.getAttribute('aria-expanded'), 'false');
+function pointerEvent(type) {
+    const event = new window.MouseEvent(type, { bubbles: true, cancelable: true, clientX: 10, clientY: 10, button: 0, view: window });
+    Object.defineProperties(event, { pointerId: { value: 1 }, pointerType: { value: 'mouse' } });
+    button.dispatchEvent(event);
+}
+pointerEvent('pointerdown');
+pointerEvent('pointerup');
+await vue.nextTick();
+assert.equal(root.count, 3, 'pointer tap invokes the caller exactly once');
+root.disabled = true;
+await vue.nextTick();
+keyboard('keydown', 'Enter');
+pointerEvent('pointerdown');
+pointerEvent('pointerup');
+assert.equal(root.count, 3);
+assert.equal(button.getAttribute('tabindex'), null);
+app.unmount();
+dom.window.close();
+
+// --- 检查真实 task 包包含新控件，避免源码存在但用户无法加载。 ---
+const archive = await JSZip.loadAsync(await readFile(new URL('../dist/control/task.cgc', import.meta.url)));
+for (const file of ['config.json', 'code.js', 'layout.html', 'style.css']) {
+    assert.ok(archive.file(`task-start/${file}`), `task.cgc contains task-start/${file}`);
+}
+assert.equal(await archive.file('task-start/layout.html').async('string'),
+    (await readFile(new URL('../dist/sources/control/task-start/layout.html', import.meta.url), 'utf8')).replace(/>\s+</g, '><').trim());
+console.log('Task start caller-owned state, label override, bar/dock, keyboard, disabled and package loading passed.');