clickgo 6.7.2 → 6.8.0

package/test/dom-style.mjs

@@ -0,0 +1,261 @@
+// Run: node --experimental-vm-modules test/dom-style.mjs
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { SourceTextModule, SyntheticModule } from 'node:vm';
+import { JSDOM } from 'jsdom';
+import ts from 'typescript';
+
+const documentDom = new JSDOM('<!doctype html><html><body></body></html>');
+for (const name of ['window', 'document', 'HTMLElement', 'Element', 'Node']) {
+    Object.defineProperty(globalThis, name, { 'configurable': true, 'value': documentDom.window[name] });
+}
+window.setTimeout = () => 0;
+globalThis.ResizeObserver = class { observe() {} unobserve() {} };
+globalThis.requestAnimationFrame = () => 0;
+const values = new WeakMap();
+const reads = [];
+let computedCalls = 0;
+globalThis.getComputedStyle = (el) => {
+    ++computedCalls;
+    return new Proxy({}, {
+        get(_, name) {
+            reads.push([el, name]);
+            return values.get(el)?.[name] ?? '';
+        },
+    });
+};
+let focus = 'form-a';
+let activePanels = [];
+const formModule = new SyntheticModule(['getFocus', 'getActivePanel'], function() {
+    this.setExport('getFocus', () => focus);
+    this.setExport('getActivePanel', () => activePanels);
+});
+const emptyModule = new SyntheticModule([], function() {});
+const source = await readFile(new URL('../dist/lib/dom.ts', import.meta.url), 'utf8');
+const domModule = new SourceTextModule(ts.transpileModule(`${source}\nexport { watchTimerHandler };`, {
+    'compilerOptions': { 'target': ts.ScriptTarget.ES2022, 'module': ts.ModuleKind.ESNext },
+}).outputText);
+await domModule.link((specifier) => specifier === './form' ? formModule : emptyModule);
+await domModule.evaluate();
+const api = domModule.namespace;
+const tick = api.watchTimerHandler;
+const formA = document.createElement('div');
+formA.dataset.formId = 'form-a';
+document.body.append(formA);
+const formB = document.createElement('div');
+formB.dataset.formId = 'form-b';
+document.body.append(formB);
+
+/** --- 创建有独立计算样式值的测试元素 --- */
+function element(parent = formA, style = { 'font-size': '13px' }) {
+    const el = document.createElement('div');
+    parent.append(el);
+    values.set(el, style);
+    return el;
+}
+const events = [];
+const first = element();
+const second = element();
+const firstHandler = (name, value, old) => {
+    events.push(['first', name, value, old, reads.length]);
+    values.get(second)['font-size'] = '30px';
+};
+api.watchStyle(first, 'font-size', firstHandler, true);
+assert.deepEqual(events[0].slice(0, 4), ['first', 'font-size', '13px', '']);
+values.get(second)['font-size'] = '13px';
+api.watchStyle(second, 'font-size', (name, value, old) => {
+    events.push(['second', name, value, old, reads.length]);
+});
+const extraEvents = [];
+const extraHandler = (...args) => extraEvents.push(args);
+const beforeCalls = computedCalls;
+api.watchStyle(first, 'font-size', extraHandler);
+assert.equal(computedCalls, beforeCalls, 'repeat registration reuses the live style object');
+values.get(first)['font-size'] = '14px';
+values.get(second)['font-size'] = '15px';
+reads.length = 0;
+events.length = 0;
+tick();
+assert.equal(reads.length, 2, 'each changed property is read once, including multiple subscribers');
+assert.deepEqual(events.map(event => event.slice(0, 4)), [
+    ['first', 'font-size', '14px', '13px'],
+    ['second', 'font-size', '15px', '13px'],
+]);
+assert.ok(events.every(event => event[4] === 2), 'all style reads finish before any callback');
+assert.deepEqual(extraEvents, [['font-size', '14px', '13px']]);
+events.length = 0;
+tick();
+assert.deepEqual(events[0].slice(0, 4), ['second', 'font-size', '30px', '15px'], 'callback writes are detected in the following poll');
+events.length = 0;
+tick();
+assert.equal(events.length, 0, 'unchanged values do not notify');
+api.unwatchStyle(first, undefined, firstHandler);
+values.get(first)['font-size'] = '16px';
+tick();
+assert.equal(events.length, 0, 'removing one callback preserves the other subscriber');
+assert.deepEqual(extraEvents.at(-1), ['font-size', '16px', '14px']);
+api.unwatchStyle(first);
+assert.equal(api.isWatchStyle(first), false);
+assert.equal(first.dataset.cgStyleindex, undefined);
+api.unwatchStyle(second);
+
+// Copied DOM attributes must never reuse another element's subscription.
+const original = element();
+api.watchStyle(original, 'font-size', () => {});
+const copy = original.cloneNode();
+formA.append(copy);
+values.set(copy, { 'font-size': '20px' });
+assert.equal(api.isWatchStyle(copy), false);
+api.watchStyle(copy, 'font-size', () => {});
+assert.notEqual(copy.dataset.cgStyleindex, original.dataset.cgStyleindex);
+original.remove();
+activePanels = ['nonexistent'];
+tick();
+assert.equal(api.isWatchStyle(original), false);
+assert.equal(original.dataset.cgStyleindex, undefined);
+formA.append(original);
+api.watchStyle(original, 'font-size', () => {});
+assert.equal(api.isWatchStyle(original), true, 'a detached and reinserted element can be registered again');
+api.clearWatchStyle('form-a');
+assert.equal(api.isWatchStyle(copy), false);
+assert.equal(api.isWatchStyle(original), false);
+
+// Keep focused Form and active Panel filtering, including delayed changes on activation.
+const panel = document.createElement('div');
+panel.dataset.panelId = 'panel-a';
+formA.append(panel);
+const main = element();
+const panelItem = element(panel);
+const otherFormItem = element(formB);
+const scopedEvents = [];
+for (const [label, el] of [['main', main], ['panel', panelItem], ['other', otherFormItem]]) {
+    api.watchStyle(el, 'font-size', () => scopedEvents.push(label));
+    values.get(el)['font-size'] = '18px';
+}
+activePanels = [];
+tick();
+assert.deepEqual(scopedEvents, ['main']);
+activePanels = ['panel-a'];
+tick();
+assert.deepEqual(scopedEvents, ['main', 'panel']);
+focus = 'form-b';
+tick();
+assert.deepEqual(scopedEvents, ['main', 'panel', 'other']);
+api.clearWatchStyle('form-a', 'panel-a');
+assert.equal(api.isWatchStyle(main), true);
+assert.equal(api.isWatchStyle(panelItem), false);
+api.clearWatchStyle('form-a');
+api.clearWatchStyle('form-b');
+focus = 'form-a';
+activePanels = ['panel-a'];
+
+// An earlier notification may cancel records already collected for this poll.
+const cancelFirst = element();
+const cancelSecond = element();
+let cancelledCalls = 0;
+api.watchStyle(cancelFirst, 'font-size', () => api.clearWatchStyle('form-a'));
+api.watchStyle(cancelSecond, 'font-size', () => ++cancelledCalls);
+values.get(cancelFirst)['font-size'] = '22px';
+values.get(cancelSecond)['font-size'] = '22px';
+tick();
+assert.equal(cancelledCalls, 0, 'clearing a Form cancels queued notifications');
+assert.equal(api.isWatchStyle(cancelSecond), false);
+
+const named = element(formA, { 'font-size': '13px', 'font-family': 'sans-serif' });
+api.watchStyle(named, ['font-size', 'font-family'], () => {});
+api.unwatchStyle(named, 'font-size');
+assert.equal(api.isWatchStyle(named), true);
+assert.deepEqual(api.getWatchInfo().default.unknown.style.list, ['font-family']);
+api.unwatchStyle(named, 'font-family');
+assert.equal(api.isWatchStyle(named), false);
+
+// Removing a later queued element also suppresses its notification and releases its index.
+const removeFirst = element();
+const removeSecond = element();
+api.watchStyle(removeFirst, 'font-size', () => removeSecond.remove());
+api.watchStyle(removeSecond, 'font-size', () => ++cancelledCalls);
+values.get(removeFirst)['font-size'] = '19px';
+values.get(removeSecond)['font-size'] = '19px';
+tick();
+assert.equal(cancelledCalls, 0);
+assert.equal(api.isWatchStyle(removeSecond), false);
+api.unwatchStyle(removeFirst);
+const immediateCancel = element(formA, { 'font-size': '13px', 'font-family': 'sans-serif' });
+const immediateNames = [];
+api.watchStyle(immediateCancel, ['font-size', 'font-family'], name => {
+    immediateNames.push(name);
+    api.unwatchStyle(immediateCancel);
+}, true);
+assert.deepEqual(immediateNames, ['font-size']);
+assert.equal(api.isWatchStyle(immediateCancel), false);
+
+// Reentrant registration retains per-property subscription order and cancellation.
+const reentrant = element();
+let registeredCalls = 0;
+const registered = () => ++registeredCalls;
+api.watchStyle(reentrant, 'font-size', () => api.watchStyle(reentrant, 'font-size', registered));
+values.get(reentrant)['font-size'] = '14px';
+tick();
+assert.equal(registeredCalls, 0, 'a callback registered during dispatch does not receive an old queued change');
+values.get(reentrant)['font-size'] = '15px';
+tick();
+assert.equal(registeredCalls, 1);
+api.unwatchStyle(reentrant);
+
+// A failed subscriber must not discard collected changes or stop subsequent polls.
+const failing = element();
+const following = element();
+const followingValues = [];
+api.watchStyle(failing, 'font-size', () => { throw new Error('test subscriber failure'); });
+api.watchStyle(following, 'font-size', (name, value) => followingValues.push(value));
+values.get(failing)['font-size'] = '17px';
+values.get(following)['font-size'] = '17px';
+tick();
+values.get(following)['font-size'] = '18px';
+tick();
+assert.deepEqual(followingValues, ['17px', '18px']);
+api.clearWatchStyle('form-a');
+
+// Stab coalesces repeated requests and discards pending measurements on unmount.
+class AbstractControl {
+    constructor() {
+        this.element = element();
+    }
+    nextTick() { return Promise.resolve(); }
+    watch(name, callback, options) { if (options?.immediate) callback(); }
+}
+const stopped = [];
+const clickgoModule = new SyntheticModule(['control', 'dom'], function() {
+    this.setExport('control', { AbstractControl });
+    this.setExport('dom', {
+        'watchSizeMulti': () => true,
+        'unwatchSizeMulti': (...args) => stopped.push(args),
+        'watchStyle': api.watchStyle,
+        'unwatchStyle': api.unwatchStyle,
+    });
+});
+const stabSource = await readFile(new URL('../dist/sources/control/stab/code.ts', import.meta.url), 'utf8');
+const stabModule = new SourceTextModule(ts.transpileModule(stabSource, {
+    'compilerOptions': { 'target': ts.ScriptTarget.ES2022, 'module': ts.ModuleKind.ESNext },
+}).outputText);
+await stabModule.link(() => clickgoModule);
+await stabModule.evaluate();
+const stab = new stabModule.namespace.default();
+stab.props.type = 'rect';
+let measurements = 0;
+stab.resize = () => ++measurements;
+stab.onMounted();
+for (let i = 0; i < 9; ++i) stab.requestResize();
+await Promise.resolve();
+assert.equal(measurements, 1);
+const unrelated = () => {};
+api.watchStyle(stab.element, 'font-size', unrelated);
+stab.requestResize();
+stab.onBeforeUnmount();
+await Promise.resolve();
+assert.equal(measurements, 1, 'unmount cancels pending geometry measurement');
+assert.equal(stopped.length, 1);
+assert.equal(api.isWatchStyle(stab.element), true, 'unmount preserves unrelated style subscribers');
+assert.deepEqual(api.getWatchInfo().default.unknown.style.list, ['font-size']);
+api.unwatchStyle(stab.element);
+console.log('Style read batching, callback order/cancellation, DOM identity, Form/Panel isolation and stab resize coalescing passed.');

package/test/form-launcher.mjs

@@ -0,0 +1,102 @@
+// Run: node test/form-launcher.mjs
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import vm from 'node:vm';
+import { JSDOM } from 'jsdom';
+import ts from 'typescript';
+
+const dom = new JSDOM('<!doctype html><html><body><div id="cg-launcher"></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 errors = [];
+window.addEventListener('error', e => errors.push(e.error));
+const vue = await import('vue');
+const pointer = await import('../node_modules/@litert/pointer/dist/index.esm.js');
+const source = await readFile(process.argv[2] ?? new URL('../dist/lib/form.ts', import.meta.url), 'utf8');
+const tree = ts.createSourceFile('form.ts', source, ts.ScriptTarget.ES2022, true);
+let config;
+function find(node) {
+    if (ts.isVariableDeclaration(node) && node.name.getText(tree) === 'launcherApp') {
+        config = node.initializer.arguments[0].getText(tree);
+    }
+    ts.forEachChild(node, find);
+}
+find(tree);
+assert.ok(config, 'load the actual launcher template and handlers');
+let hidden = 0;
+const runs = [];
+const exports = {};
+const scope = {
+    exports, document,
+    clickgo: { modules: { pointer } },
+    info: { locale: { en: { search: 'Search' } } },
+    lCore: { config: { locale: 'en', 'launcher.list': [
+        { name: 'App', path: '/app', icon: '' },
+        { name: 'Folder', list: [{ name: 'Child', path: '/child', icon: '' }] },
+    ] } },
+    lTask: { async run(...args) { runs.push(args); } },
+    sysId: 'system',
+    hideLauncher() { ++hidden; },
+    requestAnimationFrame(callback) { callback(); },
+    setTimeout() { return 0; },
+    launcherRoot: null,
+};
+vm.runInNewContext(ts.transpileModule(`export default ${config};`, {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+}).outputText, scope);
+const app = vue.createApp(exports.default);
+const root = app.mount('#cg-launcher');
+const list = document.querySelector('.cg-launcher-list');
+const search = document.querySelector('.cg-launcher-search');
+
+function event(target, type, x, y, button = 0) {
+    const e = new window.MouseEvent(type, { bubbles: true, clientX: x, clientY: y, button, view: window });
+    Object.defineProperties(e, { pointerId: { value: 1 }, pointerType: { value: 'mouse' } });
+    target.dispatchEvent(e);
+}
+async function click(target, { start = [100, 200], end = start, cancel = false, button = 0 } = {}) {
+    event(target, 'pointerdown', ...start, button);
+    event(target, cancel ? 'pointercancel' : 'pointerup', ...end, button);
+    if (!cancel) { event(target, 'click', ...end, button); }
+    await vue.nextTick();
+}
+await click(list);
+assert.equal(hidden, 1, 'stationary list blank click closes');
+await click(list, { end: [101, 201] });
+assert.equal(hidden, 2, 'minor pointer movement still counts as a click');
+await click(list, { start: [100.4, 200.4], end: [100, 200] });
+assert.equal(hidden, 3, 'fractional pointer coordinates do not reject a click');
+await click(list, { end: [120, 180] });
+await click(list, { cancel: true });
+await click(list, { button: 2 });
+assert.equal(hidden, 3, 'diagonal drag, cancellation and right click do not close');
+await click(search);
+await click(document.querySelector('.cg-launcher-space'));
+assert.equal(hidden, 5, 'search padding and item spacers close');
+await click(document.querySelector('input'));
+assert.equal(hidden, 5, 'search input stays interactive');
+await click(document.querySelector('.cg-launcher-icon'), { end: [101, 201] });
+assert.equal(hidden, 6);
+assert.deepEqual(runs.map(args => args[1]), ['/app'], 'app runs once without a bubbled blank click');
+const folder = document.querySelector('.cg-launcher-folder > div');
+for (const target of folder.querySelectorAll('.cg-launcher-icon, .cg-launcher-inner, .cg-launcher-item, .cg-launcher-space')) {
+    await click(target);
+    assert.equal(root.folderName, 'Folder', 'every collapsed preview target opens its folder');
+    assert.equal(hidden, 6, 'collapsed previews do not dismiss the launcher');
+    assert.deepEqual(runs.map(args => args[1]), ['/app'], 'collapsed previews never start a child app');
+    await click(search);
+}
+await click(folder, { end: [101, 201] });
+assert.equal(root.folderName, 'Folder');
+await click(search);
+assert.equal(root.folderName, '', 'blank click closes the folder before the launcher');
+assert.equal(hidden, 6);
+await click(folder);
+await click(folder.querySelector('.cg-launcher-icon'), { end: [101, 201] });
+assert.equal(hidden, 7);
+assert.deepEqual(runs.map(args => args[1]), ['/app', '/child'], 'folder child runs once');
+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.');

package/test/form-native-regions.mjs

@@ -0,0 +1,115 @@
+// Run after Sass compilation: node test/form-native-regions.mjs (requires an Electron display).
+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 { createSSRApp } from 'vue';
+import { renderToString } from '@vue/server-renderer';
+
+if (!process.versions.electron) {
+    const child = spawn(electron, [fileURLToPath(import.meta.url), '--ozone-platform=x11'], {
+        'env': { ...process.env, 'ELECTRON_DEBUG_DRAGGABLE_REGIONS': '1' },
+        'stdio': ['ignore', 'ignore', 'pipe'],
+    });
+    let output = '';
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', chunk => { output += chunk; });
+    const timeout = setTimeout(() => child.kill(), 20000);
+    const code = await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('exit', resolve);
+    });
+    clearTimeout(timeout);
+    assert.equal(code, 0, output);
+    let region;
+    const cases = new Map();
+    for (const line of output.split('\n')) {
+        const update = /hit-test region computed in .*?: (\d+) rect\(s\), bounds (\S+ \S+)/.exec(line);
+        if (update) {
+            region = { 'rects': Number(update[1]), 'bounds': update[2] };
+        }
+        const completed = /CASE-END (\S+)/.exec(line);
+        if (completed) {
+            assert.ok(region, 'Electron must report an actual native drag region');
+            cases.set(completed[1], region);
+        }
+    }
+    assert.equal(cases.size, 8, output);
+    assert.ok(cases.get('baseline').rects > 0);
+    for (const name of ['bottom', 'hidden', 'minimized', 'bottom-restored', 'nested', 'closed']) {
+        assert.deepEqual(cases.get(name), cases.get('baseline'), `${name} must preserve the native title drag region`);
+    }
+    assert.equal(cases.get('foreground').rects, 0, `an overlapping foreground Form must still block native dragging\n${output}`);
+    console.log('Electron native drag regions passed: bottomMost, hidden, minimized, nested, foreground and close.');
+}
+else {
+    const { app, BrowserWindow } = electron;
+    app.commandLine.appendSwitch('enable-logging');
+    /** --- 等待 Chromium 将布局更新发送给 Native 命中区域计算器 --- */
+    const settle = () => new Promise(resolve => setTimeout(resolve, 350));
+    app.whenReady().then(async () => {
+        const win = new BrowserWindow({
+            'show': false, 'frame': false, 'width': 400, 'height': 300,
+            'webPreferences': { 'backgroundThrottling': false },
+        });
+        try {
+            const template = await readFile(new URL('../dist/sources/control/form/layout.html', import.meta.url), 'utf8');
+            const style = await readFile(new URL('../dist/sources/control/form/style.css', import.meta.url), 'utf8');
+            /**
+             * --- 用实际 Form 模板生成 Native 主窗体与后创建的背景窗体 ---
+             * @param nativeFirst 是否为 Native 主窗体
+             * @returns 已渲染的 Form HTML
+             */
+            async function render(nativeFirst) {
+                const form = createSSRApp({
+                    template,
+                    data: () => ({
+                        'border': nativeFirst ? 'normal' : 'none',
+                        'isNative': true, 'isNativeNoFrameFirst': nativeFirst,
+                        'flashTimer': undefined, 'stateMinData': false, 'stateMaxData': false,
+                        'taskPosition': 'bottom', 'isShow': true, 'isInside': false,
+                        'formFocus': nativeFirst, 'widthData': 400, 'heightData': 300,
+                        'leftData': 0, 'topData': 0, 'zIndex': nativeFirst ? 10 : 1,
+                        'isMask': false, 'isResize': false, 'iconDataUrl': '', 'title': 'Native',
+                        'isMin': true, 'isMax': true, 'isClose': true, 'direction': 'v',
+                        'background': '', 'contentPadding': '', 'stepShowData': false,
+                        'stepData': [], 'stepValue': '', 'isLoading': false,
+                    }),
+                });
+                form.component('cg-step', { 'render': () => null });
+                form.component('cg-loading', { 'render': () => null });
+                return await renderToString(form);
+            }
+            const native = await render(true);
+            const background = await render(false);
+            await win.loadURL(`data:text/html,${encodeURIComponent(`<style>body{margin:0}${style}</style><div id="native">${native}</div><div id="background"></div>`)}`);
+            await settle();
+            console.error('CASE-END baseline');
+            const scripts = [
+                ['bottom', `document.querySelector('#background').innerHTML=${JSON.stringify(background)};const bg=document.querySelector('#background>.wrap');bg.dataset.cgBottomMost='';`],
+                ['hidden', `const bg=document.querySelector('#background>.wrap');delete bg.dataset.cgBottomMost;bg.classList.remove('show');`],
+                ['minimized', `const bg=document.querySelector('#background>.wrap');bg.classList.add('show');bg.dataset.cgMin='';`],
+                ['foreground', `const bg=document.querySelector('#background>.wrap');delete bg.dataset.cgMin;bg.style.zIndex='20';`],
+                ['bottom-restored', `const bg=document.querySelector('#background>.wrap');bg.style.zIndex='1';bg.dataset.cgBottomMost='';`],
+                ['nested', `document.querySelector('#background .content').innerHTML=${JSON.stringify(background)};`],
+                ['closed', `document.querySelector('#background').replaceChildren();`],
+            ];
+            for (const [name, script] of scripts) {
+                await win.webContents.executeJavaScript(`{${script}}`);
+                // --- 隐藏测试窗口也必须完成布局和绘制，不能读取上一帧的命中区域 ---
+                await win.webContents.capturePage();
+                await settle();
+                console.error(`CASE-END ${name}`);
+            }
+        }
+        catch (error) {
+            console.error(error);
+            app.exit(1);
+        }
+        finally {
+            win.destroy();
+            app.quit();
+        }
+    }).catch(error => { console.error(error); app.exit(1); });
+}

package/test/form-viewport.mjs

@@ -5,20 +5,27 @@ import vm from 'node:vm';
 import ts from 'typescript';
 
 let nativeMode = false;
+let area = { left: 0, top: 0, width: 640, height: 400, owidth: 640, oheight: 440 };
+const bool = value => value === true || value === '' || value === 'true';
 const clickgo = {
     isNative: () => nativeMode,
     control: {
         AbstractControl: class {
-            emit() {}
+            constructor() { this.rootForm = { bottomMost: false }; this.parent = { controlName: 'root' }; this.watches = {}; this.events = []; }
+            emit(...event) { this.events.push(event); }
+            propBoolean(name) { return bool(this.props[name]); }
+            watch(name, callback, options) { this.watches[name] = callback; if(options?.immediate) callback(); }
             propInt(name) { return Number(this.props[name]); }
             trigger() { return Promise.resolve(); }
         },
     },
+    core: { getAvailArea: () => area },
+    dom: { watchSize() {} },
     native: {
         restore: async () => {},
         size: async () => {},
     },
-    tool: { sleep: () => Promise.resolve() },
+    tool: { sleep: () => Promise.resolve(), getBoolean: bool },
 };
 const source = await readFile(new URL('../dist/sources/control/form/code.ts', import.meta.url), 'utf8');
 const compiled = ts.transpileModule(source, {
@@ -48,3 +55,73 @@ assert.deepEqual(restore({ width: 600, height: 40, left: 40, top: 400 }), [600,
 assert.deepEqual(restore({ width: 900, height: 700, left: 500, top: 300 }, 'native-framed'), [900, 700, 500, 300]);
 assert.deepEqual(restore({ width: 900, height: 700, left: 500, top: 300 }, 'native-frameless'), [900, 700, 500, 300]);
 console.log('Form restore stays visible, edge-positioned Forms stay anchored, and Native geometry is unchanged.');
+
+
+nativeMode = false;
+function create(viewport = false, initialMax = false) {
+    const form = new Form();
+    form.props.viewport = viewport;
+    form.props.stateMax = initialMax;
+    form.props.padding = 'safe';
+    form.element = { style: {}, dataset: {}, offsetWidth: 300, offsetHeight: 200, removeAttribute() {} };
+    form.onMounted();
+    if (!initialMax) form.maxMethod();
+    return form;
+}
+function rect(form) { return [form.leftData, form.topData, form.widthData, form.heightData]; }
+const full = create(true, true);
+assert.deepEqual(rect(full), [0, 0, 640, 440], 'initial state-max uses the full viewport');
+const history = JSON.stringify(full.historyLocation);
+for (const a of [
+    { left: 0, top: 0, width: 640, height: 400, owidth: 640, oheight: 440, padding: '0px 0px 40px 0px' },
+    { left: 60, top: 0, width: 580, height: 440, owidth: 640, oheight: 440, padding: '0px 0px 0px 60px' },
+    { left: 0, top: 40, width: 640, height: 400, owidth: 640, oheight: 440, padding: '40px 0px 0px 0px' },
+    { left: 0, top: 0, width: 580, height: 440, owidth: 640, oheight: 440, padding: '0px 60px 0px 0px' },
+    { left: 0, top: 0, width: 800, height: 520, owidth: 800, oheight: 560, padding: '0px 0px 40px 0px' },
+    { left: 0, top: 0, width: 800, height: 560, owidth: 800, oheight: 560, padding: '0px 0px 0px 0px' }
+]) {
+    area = a;
+    full.refreshMaxPosition();
+    assert.deepEqual(rect(full), [0, 0, a.owidth, a.oheight]);
+    assert.equal(full.contentPadding, a.padding);
+    assert.equal(JSON.stringify(full.historyLocation), history, 'refresh never overwrites restore geometry');
+}
+area = { left: 60, top: 0, width: 580, height: 440, owidth: 640, oheight: 440 };
+full.props.viewport = false;
+full.watches.viewport();
+assert.deepEqual(rect(full), [60, 0, 580, 440]);
+assert.equal(full.contentPadding, '0px 0px 0px 0px', 'available-area maximization does not reserve the taskbar twice');
+full.props.viewport = 'true';
+full.watches.viewport();
+assert.deepEqual(rect(full), [0, 0, 640, 440]);
+full.maxMethod();
+assert.equal(full.contentPadding, undefined, 'safe padding is removed when restoring');
+full.props.padding = '4 8';
+assert.equal(full.contentPadding, '4px 8px', 'numeric padding is unchanged');
+const normal = create();
+assert.deepEqual(rect(normal), [60, 0, 580, 440], 'default maximization still avoids the taskbar');
+const bottom = create();
+bottom.rootForm.bottomMost = true;
+bottom.refreshMaxPosition();
+assert.deepEqual(rect(bottom), [60, 0, 580, 440], 'bottomMost alone does not change the layout boundary');
+assert.equal(bottom.contentPadding, '0px 0px 0px 0px');
+bottom.props.viewport = true;
+bottom.watches.viewport();
+assert.deepEqual(rect(bottom), [0, 0, 640, 440], 'bottomMost uses the full viewport only when explicitly enabled');
+assert.equal(bottom.contentPadding, '0px 0px 0px 60px');
+bottom.props.viewport = false;
+bottom.watches.viewport();
+assert.deepEqual(rect(bottom), [60, 0, 580, 440], 'disabling viewport also restores taskbar exclusion for bottomMost');
+const inline = create();
+inline.isInside = true;
+const previous = rect(inline);
+inline.props.viewport = true;
+inline.refreshMaxPosition();
+assert.deepEqual(rect(inline), previous, 'inline Forms do not resize to the viewport');
+const automatic = create();
+automatic.props.width = 0;
+automatic.props.height = 0;
+automatic.events = [];
+automatic.refreshMaxPosition();
+assert.ok(automatic.events.every(([name]) => !['update:width', 'update:height'].includes(name)));
+console.log('Form viewport bounds, four taskbar edges, safe padding, live switching, restore and bottomMost layout independence passed.');

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', 'compact-dark', 'compact-light'];
+const themes = ['admin', 'cyber', 'dark', 'light', 'modern', 'modern-light', 'software-dark', 'software-light'];
 /** --- CGA 格式常量，与编译器的公开包格式保持一致 --- */
 const cgaHeaderLength = 106;
 const cgaKeyContext = Buffer.from('ClickGo/Application/Package');