clickgo 6.3.0 → 6.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clickgo",
-  "version": "6.3.0",
+  "version": "6.4.1",
   "description": "Background interface, software interface, mobile phone APP interface operation library.",
   "type": "module",
   "keywords": [

package/test/dock-lifecycle.mjs

@@ -0,0 +1,93 @@
+// Run after TypeScript compilation: node --experimental-vm-modules test/dock-lifecycle.mjs
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { SourceTextModule, SyntheticModule } from 'node:vm';
+
+const sizeWatches = [];
+const sizeUnwatches = [];
+
+class AbstractControl {
+    constructor(rootForm, height) {
+        this.rootForm = rootForm;
+        this.refs = {
+            'body': { 'clientHeight': height }
+        };
+    }
+
+    watch(name, callback, options) {
+        if ((name === 'expanded') && options?.immediate) {
+            callback();
+        }
+    }
+
+    async nextTick() {}
+
+    propBoolean(name) {
+        return Boolean(this.props[name]);
+    }
+
+    emit() {}
+}
+
+const clickgo = new SyntheticModule(['control', 'dom'], function() {
+    this.setExport('control', { AbstractControl });
+    this.setExport('dom', {
+        watchSizeMulti(current, element, handler, immediate) {
+            sizeWatches.push({ current, element, handler });
+            if (immediate) {
+                handler();
+            }
+            return true;
+        },
+        unwatchSizeMulti(current, element, handler) {
+            sizeUnwatches.push({ current, element, handler });
+        },
+        watchSize(current, element, handler, immediate) {
+            if (immediate) {
+                handler();
+            }
+            return true;
+        }
+    });
+});
+const mod = new SourceTextModule(await readFile(new URL('../dist/sources/control/dock/code.js', import.meta.url), 'utf8'));
+await mod.link(() => clickgo);
+await mod.evaluate();
+const Dock = mod.namespace.default;
+
+const formA = { 'element': { 'isConnected': true, 'offsetWidth': 500 } };
+const formB = { 'element': { 'isConnected': true, 'offsetWidth': 800 } };
+const dockA1 = new Dock(formA, 300);
+const dockA2 = new Dock(formA, 400);
+const dockB = new Dock(formB, 500);
+
+await dockA1.onMounted();
+await dockA2.onMounted();
+await dockB.onMounted();
+
+assert.notEqual(dockA1.access, dockA2.access);
+assert.notEqual(dockA1.access.formSizeWatch, dockA2.access.formSizeWatch);
+assert.equal(dockA1.narrow, true);
+assert.equal(dockA2.narrow, true);
+assert.equal(dockB.narrow, false);
+assert.equal(dockA1.floatAreaHeight, 300);
+assert.equal(dockA2.floatAreaHeight, 400);
+assert.equal(dockB.floatAreaHeight, 500);
+
+dockB.toggleFloat(1);
+dockA1.toggleFloat(2);
+dockA2.toggleFloat(3);
+assert.equal(dockA1.floatGroup, -1);
+assert.equal(dockA2.floatGroup, 3);
+assert.equal(dockB.floatGroup, 1);
+
+const dockA1Watch = dockA1.access.formSizeWatch;
+dockA1.onUnmounted();
+assert.equal(dockA1.access.formSizeWatch, null);
+assert.equal(sizeUnwatches.length, 1);
+assert.equal(sizeUnwatches[0].current, dockA1);
+assert.equal(sizeUnwatches[0].element, formA.element);
+assert.equal(sizeUnwatches[0].handler, dockA1Watch.handler);
+assert.equal(sizeWatches.length, 3);
+
+console.log('Dock access state, Form isolation and size-watch cleanup checks passed.');

package/test/tool-clone.mjs

@@ -0,0 +1,42 @@
+// Run after TypeScript compilation: node test/tool-clone.mjs
+import assert from 'node:assert/strict';
+import { clone } from '../dist/lib/tool.js';
+
+const shared = { 'value': 1 };
+const source = {
+    'map': new Map(),
+    'set': new Set(),
+    shared,
+    'alias': shared,
+    'date': new Date('2026-09-20T00:00:00.000Z'),
+};
+source.self = source;
+source.map.set(shared, source);
+source.set.add(shared);
+source.set.add(source);
+
+const first = clone(source);
+const second = clone(source);
+
+assert.notEqual(first, source);
+assert.notEqual(first, second);
+assert(first.map instanceof Map);
+assert(first.set instanceof Set);
+assert.notEqual(first.map, source.map);
+assert.notEqual(first.map, second.map);
+assert.notEqual(first.set, source.set);
+assert.notEqual(first.set, second.set);
+assert.equal(first.self, first);
+assert.equal(first.shared, first.alias);
+assert.notEqual(first.shared, shared);
+assert.equal(first.map.get(first.shared), first);
+assert(first.set.has(first.shared));
+assert(first.set.has(first));
+assert(first.date instanceof Date);
+assert.notEqual(first.date, source.date);
+assert.equal(first.date.getTime(), source.date.getTime());
+
+first.map.set('only-first', true);
+assert.equal(second.map.has('only-first'), false);
+
+console.log('Tool clone Map/Set, circular-reference and instance-isolation checks passed.');

package/test/web-drag-mask.mjs

@@ -0,0 +1,96 @@
+// Run: node --experimental-vm-modules test/web-drag-mask.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 dom = new JSDOM('<!doctype html><html><head></head><body></body></html>');
+for (const name of ['window', 'document', 'Element', 'SVGElement', 'Node', 'HTMLElement']) {
+    globalThis[name] = dom.window[name];
+}
+globalThis.getComputedStyle = dom.window.getComputedStyle.bind(dom.window);
+const { createApp, compile, reactive, nextTick } = await import('vue');
+const pointer = await import('@litert/pointer');
+const state = reactive({ move: false });
+const clickgo = new SyntheticModule(['control', 'dom'], function() {
+    this.setExport('control', { AbstractControl: class {} });
+    this.setExport('dom', { is: state });
+});
+const source = await readFile(new URL('../dist/sources/control/web/code.ts', import.meta.url), 'utf8');
+const web = new SourceTextModule(ts.transpileModule(source, {
+    compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext },
+}).outputText);
+await web.link(() => clickgo);
+await web.evaluate();
+const control = new web.namespace.default();
+
+// Exercise the actual launcher hooks with the installed Pointer library.
+const launcher = await readFile(new URL('../dist/clickgo.ts', import.meta.url), 'utf8');
+const hookSource = launcher.match(/    modules\.pointer\.addMoveHook\('down',[\s\S]*?    modules\.pointer\.addMoveHook\('up',[\s\S]*?    \}\);/)[0];
+const hooks = new SourceTextModule(`import { pointer, is } from 'bridge';
+    const modules = { pointer }; const lDom = { is }; ${hookSource}`);
+const bridge = new SyntheticModule(['pointer', 'is'], function() {
+    this.setExport('pointer', pointer);
+    this.setExport('is', state);
+});
+await hooks.link(() => bridge);
+await hooks.evaluate();
+
+const template = await readFile(new URL('../dist/sources/control/web/layout.html', import.meta.url), 'utf8');
+const host = document.createElement('div');
+document.body.append(host);
+const app = createApp({
+    render: compile(template),
+    data: () => ({ src: 'about:blank' }),
+    computed: { showMask: () => control.showMask },
+});
+app.mount(host);
+const iframe = host.querySelector('iframe');
+const mask = host.querySelector('.mask');
+assert.equal(iframe.getAttribute('src'), 'about:blank');
+assert.equal(mask.style.display, 'none');
+
+function event(type, x, y) {
+    const e = new dom.window.Event(type, { bubbles: true, cancelable: true });
+    Object.assign(e, { clientX: x, clientY: y, pointerId: 1, pointerType: 'mouse', button: 0 });
+    return e;
+}
+
+for (const operation of ['move', 'resize']) {
+    for (const finish of ['pointerup', 'pointercancel']) {
+        let updates = 0;
+        const handle = document.createElement('div');
+        document.body.append(handle);
+        handle.addEventListener('pointerdown', e => {
+            if (operation === 'resize') {
+                pointer.resize(e, {
+                    border: 'rb', objectLeft: 0, objectTop: 0,
+                    objectWidth: 400, objectHeight: 300,
+                    move: () => { ++updates; },
+                });
+            }
+            else {
+                pointer.move(e, { move: () => { ++updates; } });
+            }
+        });
+        handle.dispatchEvent(event('pointerdown', 400, 300));
+        await nextTick();
+        assert.equal(state.move, true);
+        assert.notEqual(mask.style.display, 'none');
+        mask.dispatchEvent(event('pointermove', 350, 250));
+        mask.dispatchEvent(event('pointermove', 320, 230));
+        assert.equal(updates, 2);
+        mask.dispatchEvent(event(finish, 320, 230));
+        await nextTick();
+        assert.equal(state.move, false);
+        assert.equal(mask.style.display, 'none');
+        mask.dispatchEvent(event('pointermove', 300, 200));
+        assert.equal(updates, 2);
+        assert.equal(host.querySelector('iframe'), iframe);
+        handle.remove();
+    }
+}
+app.unmount();
+dom.window.close();
+console.log('WEB drag/resize mask, pointerup/cancel cleanup and iframe preservation checks passed.');