clickgo 6.7.2 → 6.8.1

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-notify.mjs

@@ -0,0 +1,90 @@
+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><div id="notify"></div>');
+const { document } = dom.window;
+const notify = document.getElementById('notify');
+Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetHeight', {
+    get() { return Number(this.dataset.height ?? 96); },
+});
+const frames = [];
+const timers = new Map();
+const observed = new Set();
+let timerId = 0;
+let observerCallback;
+let area = { left: 0, top: 0, width: 800, height: 600 };
+const core = { config: { locale: 'en' }, getAvailArea: () => area };
+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 api = {};
+vm.runInNewContext(ts.transpileModule(source.slice(start, end), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+}).outputText, {
+    exports: api, document, elements: { notify }, lCore: core,
+    lTool: { lang: { getDirection: locale => locale === 'ar' ? 'rtl' : 'ltr' }, escapeHTML: value => value },
+    window: { innerWidth: 800, innerHeight: 600, setTimeout: schedule },
+    setTimeout: schedule, clearTimeout: id => timers.delete(id),
+    requestAnimationFrame: cb => frames.push(cb),
+    ResizeObserver: class {
+        constructor(callback) { observerCallback = callback; }
+        observe(el) { observed.add(el); }
+        unobserve(el) { observed.delete(el); }
+    },
+});
+function schedule(callback, delay) { const id = ++timerId; timers.set(id, { callback, delay }); return id; }
+function frame() { frames.splice(0).forEach(callback => callback()); }
+function remove() {
+    for (const [id, timer] of [...timers]) {
+        if (timer.delay === 100) { timers.delete(id); timer.callback(); }
+    }
+}
+function position(el) { return [...el.style.transform.matchAll(/\((-?[\d.]+)px\)/g)].map(match => Number(match[1])); }
+const firstId = api.notify({ title: 'Loading', content: 'Task', note: 'Start', timeout: 0 });
+const first = notify.children[0];
+area.height = 552; // Task bar appears before the enter frame.
+api.refreshNotifyPosition();
+frame();
+assert.deepEqual(position(first), [-58, -10]);
+const secondId = api.notify({ title: 'Loading', content: 'Demo', note: 'Start', timeout: 0 });
+const second = notify.children[1];
+frame();
+assert.deepEqual(position(second), [-164, -10], 'notifications share the current task bar offset');
+first.dataset.height = '128.5';
+api.notifyContent(firstId, { note: 'Wrapped content' });
+assert.deepEqual(position(second), [-196.5, -10], 'content growth uses actual fractional height');
+first.dataset.height = '146';
+observerCallback();
+assert.deepEqual(position(second), [-214, -10], 'size observer also restacks notifications');
+area = { left: 0, top: 0, width: 750, height: 600 };
+api.refreshNotifyPosition();
+assert.deepEqual(position(first), [-10, -60], 'right bar moves the existing stack left');
+core.config.locale = 'ar';
+area = { left: 50, top: 0, width: 750, height: 600 };
+api.refreshNotifyPosition();
+assert.deepEqual(position(first), [-10, 60], 'RTL avoids the left task bar');
+area = { left: 0, top: 50, width: 800, height: 550 };
+api.refreshNotifyPosition();
+assert.deepEqual(position(first), [-10, 10], 'top bar does not push the bottom anchor');
+api.hideNotify(firstId);
+api.hideNotify(firstId);
+assert.equal([...timers.values()].filter(timer => timer.delay === 100).length, 1, 'duplicate hides are idempotent');
+remove();
+assert.deepEqual(position(second), [-10, 10], 'removing a notification closes its space');
+assert.equal(observed.has(first), false, 'removed notifications release size subscriptions');
+api.hideNotify(secondId); remove();
+const earlyId = api.notify({ content: 'Close before entering' });
+api.hideNotify(earlyId); frame();
+assert.equal(notify.children[0].style.opacity, '0', 'pending enter cannot resurrect a closing notification');
+remove();
+assert.equal(notify.children.length, 0);
+assert.equal(observed.size, 0);
+assert.equal(timers.size, 0, 'no auto-hide timer survives an early hide');
+const next = api.notify({ content: 'Fresh stack' }); frame();
+assert.deepEqual(position(notify.children[0]), [-10, 10], 'empty stack leaves no stale offsets');
+api.hideNotify(next); remove();
+dom.window.close();
+console.log('Notify task bar appearance/movement, RTL, height changes, stacking and hide races passed.');