clickgo 6.8.0 → 6.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clickgo",
-  "version": "6.8.0",
+  "version": "6.8.1",
   "description": "Background interface, software interface, mobile phone APP interface operation library.",
   "type": "module",
   "keywords": [
@@ -14,10 +14,15 @@
   "types": "./dist/clickgo.d.ts",
   "scripts": {
     "sass": "sass --watch dist/:dist/ --style compressed --no-source-map",
-    "check": "tsc --noEmit --pretty false && eslint \"dist/**/*.ts\" --format stylish && npm run test:locale && npm run test:style && npm run test:desktop && npm run test:form",
-    "test:form": "node test/form-viewport.mjs && node --experimental-vm-modules test/form-native.mjs && node test/form-launcher.mjs",
+    "check": "tsc --noEmit --pretty false && eslint \"dist/**/*.ts\" --format stylish && npm run test:locale && npm run test:style && npm run test:desktop && npm run test:form && npm run test:task && npm run test:module && npm run test:vflow && npm run test:scroll && npm run test:jodit",
+    "test:module": "node test/tool-assets.mjs && node test/core-module-loading.mjs && node test/tuieditor-locale.mjs",
+    "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: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:native-regions": "node test/form-native-regions.mjs",
-    "test:desktop": "node --experimental-vm-modules test/desktop.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",
     "test:archive": "node test/rtl-archive.mjs",
     "test:locale": "node --experimental-vm-modules test/locale-integrity.mjs && node --experimental-vm-modules test/rtl-direction.mjs",

package/test/core-module-loading.mjs

@@ -0,0 +1,169 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import vm from 'node:vm';
+import ts from 'typescript';
+
+const source = await readFile(new URL('../dist/lib/core.ts', import.meta.url), 'utf8');
+const tree = ts.createSourceFile('core.ts', source, ts.ScriptTarget.ES2022, true);
+const names = new Set(['regModule', 'loadModule', 'getModule']);
+const selected = tree.statements.filter(node =>
+    (ts.isVariableStatement(node) && node.declarationList.declarations.some(item => item.name.getText(tree) === 'modules')) ||
+    (ts.isFunctionDeclaration(node) && node.body && names.has(node.name?.text)));
+const requests = [];
+const globals = {};
+const clickgo = { modules: {}, getCdn: () => 'https://cdn.example', getDirname: () => 'https://app.example/clickgo' };
+const api = {};
+function pending(urls) {
+    let resolve;
+    let reject;
+    const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
+    requests.push({ urls: Array.from(urls), resolve, reject });
+    return promise;
+}
+vm.runInNewContext(ts.transpileModule(selected.map(node => node.getText(tree)).join('\n'), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022, esModuleInterop: false },
+}).outputText, {
+    exports: api, window: globals, clickgo,
+    lTask: { checkPermission: async () => [true] },
+    lTool: { loadAssets: pending, loadScript: url => pending([url]), loadStyle() {}, urlResolve: (base, path) => new URL(path, base).href },
+});
+
+const xterm = api.getModule('xterm');
+const duplicate = api.getModule('xterm');
+assert.equal(requests.length, 1, 'concurrent callers share one unified resource batch');
+assert.equal(requests[0].urls.length, 4);
+assert.ok(requests[0].urls[0].endsWith('/xterm.js'));
+assert.ok(requests[0].urls[3].endsWith('/xterm.min.css'));
+assert.equal(clickgo.modules.xterm, undefined, 'modules are not published until their resources complete');
+globals.Terminal = class {};
+globals.FitAddon = { FitAddon: class {} };
+globals.WebglAddon = { WebglAddon: class {} };
+requests[0].resolve(true);
+const first = await xterm;
+assert.equal(await duplicate, first);
+assert.equal(await api.getModule('xterm'), first);
+assert.equal(requests.length, 1, 'ready modules do not reload resources');
+
+requests.length = 0;
+const toast = api.getModule('@toast-ui/editor');
+const toastWaiter = api.getModule('@toast-ui/editor');
+assert.equal(requests.length, 1, 'concurrent Toast UI callers share one batch of the local complete library and CDN styles');
+assert.equal(requests[0].urls.length, 3);
+assert.equal(requests[0].urls[0], 'https://app.example/clickgo/ext/toastui-editor-all.min.js', 'the complete library resolves relative to the framework, independently of its CDN');
+assert.ok(requests[0].urls.slice(1).every(url => url.startsWith(clickgo.getCdn() + '/npm/@toast-ui/editor@3.2.2/')), 'Toast UI styles keep the configured CDN');
+assert.equal(requests[0].urls.filter(url => url.includes('/i18n/')).length, 0, 'the shared module and pure viewer need no locale scripts');
+assert.equal(requests[0].urls.filter(url => url.endsWith('.css')).length, 2);
+const Editor = class {};
+globals.toastui = { Editor };
+assert.equal(clickgo.modules['@toast-ui/editor'], undefined, 'a script constructor is not published before the resource batch completes');
+requests[0].resolve(true);
+const toastModule = await toast;
+assert.equal(await toastWaiter, toastModule);
+assert.equal(toastModule.Editor, Editor, 'the wrapper exposes the local library constructor used by language scripts');
+assert.equal(globals.toastui.loadLanguage, undefined, 'the shared helper is separate from the native namespace');
+assert.equal(await api.getModule('@toast-ui/editor'), toastModule, 'all callers receive the same wrapper');
+requests.length = 0;
+assert.equal(await toastModule.loadLanguage('en'), true);
+assert.equal(await toastModule.loadLanguage('en-US'), true);
+assert.equal(await toastModule.loadLanguage('../unknown'), false);
+assert.equal(requests.length, 0, 'built-in English and unsupported names issue no requests');
+const locale = toastModule.loadLanguage('zh-CN');
+const localeWaiter = toastModule.loadLanguage('ZH-cn');
+assert.equal(requests.length, 1, 'normalized language names share a pending script globally');
+assert.ok(requests[0].urls[0].endsWith('/i18n/zh-cn.min.js'));
+requests[0].resolve(true);
+assert.equal(await locale, true);
+assert.equal(await localeWaiter, true);
+assert.equal(await toastModule.loadLanguage('zh-cn'), true);
+assert.equal(requests.length, 1, 'ready languages are reused');
+const badLocale = toastModule.loadLanguage('fr-FR');
+const badLocaleWaiter = toastModule.loadLanguage('fr-fr');
+requests.at(-1).resolve(false);
+assert.equal(await badLocale, false);
+assert.equal(await badLocaleWaiter, false);
+const localeRetry = toastModule.loadLanguage('fr-FR');
+assert.equal(requests.length, 3, 'failed languages can be retried');
+requests.at(-1).resolve(true);
+assert.equal(await localeRetry, true);
+
+// Resource rejection releases all waiters even when a library global already exists.
+delete clickgo.modules['@toast-ui/editor'];
+requests.length = 0;
+const resourceFailure = api.getModule('@toast-ui/editor');
+const resourceFailureWaiter = api.getModule('@toast-ui/editor');
+requests[0].reject(new Error('local library unavailable'));
+assert.equal(await resourceFailure, null);
+assert.equal(await resourceFailureWaiter, null);
+assert.equal(clickgo.modules['@toast-ui/editor'], undefined);
+requests.length = 0;
+const resourceRetry = api.getModule('@toast-ui/editor');
+requests[0].resolve(true);
+assert.equal((await resourceRetry).Editor, Editor, 'failed initialization leaves the shared module available for retry');
+
+delete clickgo.modules['@toast-ui/editor'];
+requests.length = 0;
+const missingConstructor = api.getModule('@toast-ui/editor');
+delete globals.toastui.Editor;
+requests[0].resolve(true);
+assert.equal(await missingConstructor, null, 'a missing local constructor is not published');
+requests.length = 0;
+const failedCss = api.getModule('@toast-ui/editor');
+globals.toastui.Editor = Editor;
+requests[0].resolve(false);
+assert.equal(await failedCss, null, 'a library constructor does not hide resource failure');
+
+requests.length = 0;
+const failed = api.getModule('jodit');
+const alsoFailed = api.getModule('jodit');
+assert.equal(requests.length, 1);
+requests[0].resolve(true);
+assert.equal(await failed, null, 'a missing script global is a module failure');
+assert.equal(await alsoFailed, null, 'waiting callers also receive failure instead of hanging');
+requests.length = 0;
+const retried = api.getModule('jodit');
+assert.equal(requests.length, 1, 'failure clears the in-flight state and allows retry');
+globals.Jodit = { make() {} };
+requests[0].resolve(true);
+assert.equal(await retried, globals.Jodit);
+
+requests.length = 0;
+delete clickgo.modules.jodit;
+const badAssets = api.getModule('jodit');
+const badAssetsWaiter = api.getModule('jodit');
+requests[0].resolve(false);
+assert.equal(await badAssets, null, 'any failed resource prevents publishing the module');
+assert.equal(await badAssetsWaiter, null);
+assert.equal(clickgo.modules.jodit, undefined);
+requests.length = 0;
+const assetsRetry = api.getModule('jodit');
+requests[0].resolve(true);
+assert.equal(await assetsRetry, globals.Jodit);
+
+let attempts = 0;
+let finish;
+assert.equal(await api.regModule('owner', 'retry-test', {
+    func: () => { ++attempts; return new Promise(resolve => { finish = resolve; }); },
+}), true);
+const empty = api.loadModule('retry-test');
+const emptyWaiter = api.loadModule('retry-test');
+finish(null);
+assert.equal(await empty, false);
+assert.equal(await emptyWaiter, false);
+const retry = api.loadModule('retry-test');
+finish({ ready: true });
+assert.equal(await retry, true);
+assert.equal(attempts, 2);
+
+let reject;
+assert.equal(await api.regModule('owner', 'reject-test', {
+    func: () => new Promise((resolve, no) => { reject = no; }),
+}), true);
+const rejected = api.loadModule('reject-test');
+const rejectedWaiter = api.loadModule('reject-test');
+reject(new Error('external loader failed'));
+assert.equal(await rejected, false);
+assert.equal(await rejectedWaiter, false, 'external rejections release every waiting caller');
+const secondTry = api.loadModule('reject-test');
+reject(new Error('external loader failed again'));
+assert.equal(await secondTry, false);
+console.log('Local complete Toast UI library/CDN styles, locale-free loading, shared requests, failures and retries passed.');

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.');

package/test/iconview.mjs

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { SourceTextModule, SyntheticModule } from 'node:vm';
+
+class AbstractControl {
+    element = { dir: 'ltr' };
+    emitted = [];
+    propInt(name) { return Number(this.props[name]); }
+    propBoolean(name) { return Boolean(this.props[name]); }
+    emit(name, value) { this.emitted.push([name, value]); }
+}
+const clickgo = new SyntheticModule(['control', 'dom', 'tool'], function() {
+    this.setExport('control', { AbstractControl });
+    this.setExport('dom', { isRtl: element => element.dir === 'rtl' });
+    this.setExport('tool', { clone: structuredClone });
+});
+const module = new SourceTextModule(await readFile('dist/sources/control/iconview/code.js', 'utf8'));
+await module.link(() => clickgo);
+await module.evaluate();
+const view = new module.namespace.default();
+view.props.data = Array.from({ length: 8 }, (_, i) => ({ name: 'item-' + i }));
+
+// Resizing crosses column thresholds without stretching existing cells.
+for (const [width, columns] of [[360, 2], [420, 2], [539, 2], [540, 3], [620, 3]]) {
+    view.clientwidth(width);
+    assert.equal(view.rowCount, columns);
+    assert.equal(view.cellWidth, 180);
+    assert.equal(view.dataComp[0].length, columns);
+}
+view.props.size = 64;
+assert.equal(view.cellWidth, 144);
+assert.equal(view.rowCount, 4);
+view.clientwidth(100);
+assert.equal(view.cellWidth, 100);
+assert.equal(view.rowCount, 1);
+view.clientwidth(0);
+assert.ok(Number.isFinite(view.rowCount));
+assert.equal(view.rowCount, 1);
+view.props.size = 100;
+view.clientwidth(500);
+
+function box(x, width, modifiers = {}) {
+    view.onBeforeSelect();
+    view.onSelect({ x, width, y: 0, height: 100, start: 0, end: 0, empty: false, ...modifiers });
+    return [...view.valueData];
+}
+
+// Column hit testing uses actual fixed cells; trailing whitespace selects nothing.
+assert.deepEqual(box(190, 10), [1]);
+assert.deepEqual(box(370, 80), []);
+assert.equal(view.emitted.at(-1)[1].detail.area.empty, true);
+assert.deepEqual(box(170, 200), [0, 1]);
+assert.deepEqual(box(0, 20), [0]);
+assert.deepEqual(box(370, 50, { ctrl: true }), [0]);
+assert.deepEqual(box(190, 20, { shift: true }), [0, 1]);
+view.arrowDown();
+assert.ok(view.valueData.every(index => index >= 0 && index < 8));
+
+// RTL starts at the right edge, leaving unused space at the left edge.
+view.element.dir = 'rtl';
+assert.deepEqual(box(10, 50), []);
+assert.deepEqual(box(450, 20), [0]);
+assert.deepEqual(box(280, 20), [1]);
+assert.deepEqual(box(280, 200), [0, 1]);
+view.props.multi = false;
+assert.deepEqual(box(280, 20), [1]);
+assert.deepEqual(box(10, 50), [1]);
+view.props.data = [];
+assert.deepEqual(view.dataComp, []);
+console.log('Iconview fixed cells, column thresholds, size changes, narrow widths, LTR/RTL selection and modifiers passed.');

package/test/jodit-lifecycle.mjs

@@ -0,0 +1,212 @@
+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';
+import { clone, getClassPrototype } from '../dist/lib/tool.js';
+
+const dom = new JSDOM('<!doctype html><html><body></body></html>');
+for (const name of ['window', 'document', 'Element', 'HTMLElement', 'SVGElement', 'Node']) {
+    Object.defineProperty(globalThis, name, { configurable: true, value: dom.window[name] });
+}
+const { createApp, h, nextTick, reactive } = await import('vue');
+const errors = [];
+const editors = [];
+const menus = [];
+let popCount = 0;
+let moduleCount = 0;
+let loadModule;
+
+class AbstractControl {
+    get refs() { return this.$refs; }
+    get locale() { return 'en'; }
+    watch(name, callback, options) { return this.$watch(() => this.props[name], callback, options); }
+    emit(...args) { this.$emit(...args); }
+    propBoolean(name) { return this.props[name] === true; }
+}
+const module = {
+    make(element, options) {
+        assert.ok(element instanceof HTMLElement && element.isConnected, 'Jodit requires a live host');
+        const callbacks = {};
+        const editor = {
+            value: '', text: 'plain text', container: element.parentElement,
+            options, callbacks, commands: [], images: [], destructCount: 0,
+            events: { on(name, callback) { callbacks[name] = callback; } },
+            setReadOnly(value) { this.readonly = value; },
+            execCommand(value) { this.commands.push(value); },
+            selection: { insertImage(...args) { editor.images.push(args); } },
+            destruct() {
+                assert.equal(element.isConnected, true, 'release the editor before Vue removes its DOM');
+                ++this.destructCount;
+                callbacks.change?.();
+            },
+        };
+        editors.push(editor);
+        return editor;
+    },
+};
+const clickgo = {
+    control: { AbstractControl },
+    core: { getModule() { ++moduleCount; return loadModule(); } },
+    dom: { findParentByClass() { return null; } },
+    form: { hidePop() {}, showPop() { ++popCount; } },
+    modules: { pointer: { menu(event, callback) { menus.push(callback); } } },
+};
+const source = await readFile(new URL('../dist/sources/control/jodit/code.ts', import.meta.url), 'utf8');
+const exports = {};
+vm.runInNewContext(ts.transpileModule(source, {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+}).outputText, { exports, require: () => clickgo, HTMLElement });
+const instance = new exports.default();
+const prototype = getClassPrototype(instance);
+const controls = [];
+const Control = {
+    template: '<div><div ref="content"><textarea ref="editor"></textarea><div class="jodit-workplace"></div></div><div ref="pop"></div></div>',
+    props: Object.fromEntries(Object.entries(instance.props).map(([name, value]) => [name, {
+        default: () => clone(value),
+    }])),
+    emits: instance.emits,
+    data: () => Object.fromEntries(Object.entries(new exports.default()).filter(([name]) =>
+        !['props', 'emits', 'access'].includes(name))),
+    computed: prototype.access,
+    methods: prototype.method,
+    created() {
+        this.props = this.$props;
+        this.access = clone(instance.access);
+        controls.push(this);
+    },
+    // Mirror buildComponents: its mounted hook defers the control hook by one Vue tick.
+    async mounted() { await this.$nextTick(); await this.onMounted(); },
+    beforeUnmount: prototype.method.onBeforeUnmount,
+};
+
+/** --- Drain both Vue mounting and asynchronous module continuations. --- */
+async function flush() {
+    for (let i = 0; i < 8; ++i) await nextTick();
+    assert.deepEqual(errors, [], 'Jodit lifecycle must not produce runtime errors');
+}
+
+/** --- Mount independent instances with the framework's per-instance access storage. --- */
+function mount(items) {
+    const state = reactive({ items });
+    const events = [];
+    const host = document.createElement('div');
+    document.body.append(host);
+    const app = createApp({
+        render: () => h('div', state.items.map(item => h(Control, {
+            key: item.id,
+            modelValue: item.value ?? '', readonly: item.readonly ?? false,
+            'onUpdate:modelValue': value => events.push(['value', value]),
+            onText: value => events.push(['text', value]),
+            onInit: editor => events.push(['init', editor]),
+            onImgselect: callback => events.push(['image', callback]),
+        }))),
+    });
+    app.config.errorHandler = error => errors.push(error);
+    app.mount(host);
+    return { state, events, host, unmount() { app.unmount(); host.remove(); } };
+}
+
+// A parent can replace the temporary editor before the deferred control hook even starts.
+loadModule = () => Promise.resolve(module);
+let view = mount([{ id: 'temporary' }]);
+view.state.items = [];
+await flush();
+assert.equal(moduleCount, 0);
+assert.equal(editors.length, 0);
+view.unmount();
+
+// Module resolution after unmount must neither initialize Jodit nor change fallback state.
+for (const result of [module, null]) {
+    let release;
+    loadModule = () => new Promise(resolve => { release = resolve; });
+    view = mount([{ id: 'pending' }]);
+    await flush();
+    const control = controls.at(-1);
+    view.state.items = [];
+    await flush();
+    release(result);
+    await flush();
+    assert.equal(editors.length, 0);
+    assert.equal(control.notInit, false);
+    assert.deepEqual(view.events, []);
+    view.unmount();
+}
+
+// Re-rendering one editor while a shared module loads must preserve its surviving sibling.
+let release;
+const pending = new Promise(resolve => { release = resolve; });
+loadModule = () => pending;
+view = mount([{ id: 'temporary' }, { id: 'live', value: 'before' }]);
+await flush();
+const removed = controls.at(-2);
+const live = controls.at(-1);
+assert.notEqual(removed.access, live.access);
+view.state.items.splice(0, 1);
+view.state.items[0].value = 'after';
+view.state.items[0].readonly = true;
+await flush();
+release(module);
+await flush();
+assert.equal(editors.length, 1);
+const editor = editors[0];
+assert.equal(live.access.editor, editor);
+assert.equal(editor.value, 'after');
+assert.equal(editor.readonly, true);
+view.state.items[0].value = 'updated';
+view.state.items[0].readonly = false;
+await flush();
+assert.equal(editor.value, 'updated');
+assert.equal(editor.readonly, false);
+editor.callbacks.change();
+assert.ok(view.events.some(event => event[0] === 'value' && event[1] === 'updated'));
+editor.callbacks.focus();
+assert.equal(live.isFocus, true);
+editor.callbacks.blur();
+assert.equal(live.isFocus, false);
+live.execCmd('copy');
+assert.deepEqual(editor.commands, ['copy']);
+editor.options.extraButtons[0].exec();
+const insertImage = view.events.find(event => event[0] === 'image')[1];
+const workplace = view.host.querySelector('.jodit-workplace');
+workplace.dispatchEvent(new dom.window.Event('pointerdown', { bubbles: true }));
+assert.equal(menus.length, 1);
+const eventCount = view.events.length;
+view.unmount();
+await flush();
+assert.equal(editor.destructCount, 1);
+assert.equal(live.access.editor, undefined);
+assert.equal(view.events.length, eventCount, 'destruction must not emit a model update');
+insertImage('image.png');
+menus[0]();
+workplace.dispatchEvent(new dom.window.Event('pointerdown', { bubbles: true }));
+live.execCmd('paste');
+live.onBeforeUnmount();
+assert.equal(editor.destructCount, 1, 'cleanup is idempotent');
+assert.deepEqual(editor.images, []);
+assert.equal(popCount, 0);
+assert.equal(menus.length, 1, 'remove the menu listener at unmount');
+
+// A cached module still resolves asynchronously on every later entry.
+loadModule = async () => { await Promise.resolve(); return module; };
+for (let i = 0; i < 20; ++i) {
+    view = mount([{ id: 'entry', value: `entry ${i}` }]);
+    await flush();
+    view.state.items = [{ id: 'replacement', value: `replacement ${i}` }];
+    await flush();
+    view.unmount();
+    await flush();
+}
+assert.equal(editors.length, 41);
+assert.ok(editors.every(item => item.destructCount === 1));
+
+// A genuine module load failure still displays the existing fallback.
+loadModule = () => Promise.resolve(null);
+view = mount([{ id: 'failure' }]);
+await flush();
+assert.equal(controls.at(-1).notInit, true);
+assert.equal(controls.at(-1).isLoading, false);
+view.unmount();
+await flush();
+dom.window.close();
+console.log('Jodit deferred mounting, late module resolution, instance isolation, repeated entry and editor cleanup passed.');