clickgo 6.8.2 → 6.10.0

package/test/jodit-lifecycle.mjs

@@ -1,212 +0,0 @@
-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.');

package/test/locale-integrity.mjs

@@ -1,189 +0,0 @@
-// Run: node --experimental-vm-modules test/locale-integrity.mjs
-import assert from 'node:assert/strict';
-import { access, readdir, readFile } from 'node:fs/promises';
-import { SourceTextModule } from 'node:vm';
-import { JSDOM } from 'jsdom';
-import ts from 'typescript';
-
-/** --- ClickGo 的固定内置语言顺序 --- */
-const codes = [
-    'sc', 'tc', 'ja', 'ko', 'th', 'vi', 'ar', 'id',
-    'en', 'es', 'de', 'fr', 'pt', 'ru', 'it', 'tr',
-];
-
-/** --- 仍使用问号占位符、会在运行时被替换的语言键 --- */
-const placeholderKeys = new Set([
-    'dist/lib/fs.ts:apply-unmount',
-    'dist/lib/storage.ts:sure-clear',
-    'dist/sources/control/page/code.ts:total-of',
-]);
-
-/**
- * --- 获取对象字面量的静态属性名 ---
- * @param property TypeScript 属性节点
- * @returns 属性名；动态属性返回空字符串
- */
-function getPropertyName(property) {
-    if (!ts.isPropertyAssignment(property) || !property.name) {
-        return '';
-    }
-    if (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) || ts.isNumericLiteral(property.name)) {
-        return property.name.text;
-    }
-    return '';
-}
-
-/**
- * --- 从对象字面量取静态属性 ---
- * @param object 对象字面量
- * @param key 属性名
- * @returns 属性初始化节点
- */
-function getProperty(object, key) {
-    return object.properties.find((property) => getPropertyName(property) === key)?.initializer;
-}
-
-/**
- * --- 断言翻译值是非空静态字符串 ---
- * @param value 翻译的 AST 节点
- * @param message 失败信息
- */
-function assertText(value, message) {
-    const isText = ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value);
-    assert.equal(isText, true, `${message} must be a static string literal`);
-    assert.notEqual(value.text.trim(), '', `${message} must not be empty`);
-}
-
-/**
- * --- 从 TypeScript 源码收集含英文条目的语言表 ---
- * @param path TypeScript 文件路径
- * @returns 语言表及其行号
- */
-async function collectLocaleTables(path) {
-    const source = ts.createSourceFile(path, await readFile(path, 'utf8'), ts.ScriptTarget.Latest, true);
-    const tables = [];
-    const visit = (node) => {
-        if (ts.isObjectLiteralExpression(node) && getProperty(node, 'en')) {
-            const keys = node.properties.map(getPropertyName);
-            if (codes.every((code) => keys.includes(code))) {
-                tables.push({
-                    'node': node,
-                    'line': source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1,
-                });
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(source);
-    return tables;
-}
-
-const dom = new JSDOM('<!doctype html><html><head></head><body></body></html>');
-for (const name of ['window', 'document', 'navigator']) {
-    Object.defineProperty(globalThis, name, {
-        'configurable': true,
-        'value': dom.window[name],
-    });
-}
-
-// The language registry is executed from TypeScript source, not generated JavaScript.
-const toolSource = await readFile(new URL('../dist/lib/tool.ts', import.meta.url), 'utf8');
-const toolModule = new SourceTextModule(ts.transpileModule(toolSource, {
-    'compilerOptions': {
-        'target': ts.ScriptTarget.ES2022,
-        'module': ts.ModuleKind.ESNext,
-    },
-}).outputText);
-await toolModule.link(() => {
-    throw new Error('tool.ts must not import runtime modules');
-});
-await toolModule.evaluate();
-
-const { lang } = toolModule.namespace;
-assert.deepEqual(lang.codes, codes, 'language codes must retain all 16 supported locales');
-assert.equal(lang.names.length, codes.length, 'every locale must have a display name');
-assert.equal(new Set(lang.names).size, codes.length, 'language display names must be unique');
-assert.deepEqual(Object.keys(lang.tags).sort(), [...codes].sort(), 'every locale must have an HTML lang tag');
-for (const code of codes) {
-    assert.notEqual(lang.names[lang.codes.indexOf(code)].trim(), '', `${code} must have a non-empty display name`);
-    assert.notEqual(lang.getTag(code).trim(), '', `${code} must resolve to a non-empty HTML lang tag`);
-    assert.equal(lang.getDirection(code), code === 'ar' ? 'rtl' : 'ltr', `${code} must resolve to its writing direction`);
-}
-assert.equal(lang.getDirection('ar-EG'), 'rtl', 'Arabic HTML tags must resolve to RTL');
-assert.equal(lang.getDirection('en-US'), 'ltr', 'non-Arabic HTML tags must resolve to LTR');
-
-const controlRoot = new URL('../dist/sources/control/', import.meta.url);
-const controlNames = (await readdir(controlRoot, { 'withFileTypes': true }))
-    .filter((item) => item.isDirectory())
-    .map((item) => item.name)
-    .sort();
-const controlSources = [];
-for (const name of controlNames) {
-    const path = `dist/sources/control/${name}/code.ts`;
-    try {
-        await access(path);
-        controlSources.push(path);
-    }
-    catch {}
-}
-const localeSources = [
-    'dist/lib/form.ts',
-    'dist/lib/fs.ts',
-    'dist/lib/storage.ts',
-    'dist/lib/task.ts',
-    ...controlSources,
-];
-
-const tables = [];
-for (const path of localeSources) {
-    for (const table of await collectLocaleTables(path)) {
-        tables.push({ ...table, path });
-    }
-}
-assert.equal(tables.length, 26, 'all 26 built-in TypeScript locale tables must be present');
-for (const { node, path, line } of tables) {
-    const tableCodes = node.properties.map(getPropertyName);
-    assert.deepEqual([...tableCodes].sort(), [...codes].sort(), `${path}:${line} must contain exactly 16 locale entries`);
-    const english = getProperty(node, 'en');
-    assert.equal(ts.isObjectLiteralExpression(english), true, `${path}:${line} English locale must be an object`);
-    const keys = english.properties.map(getPropertyName);
-    assert.equal(new Set(keys).size, keys.length, `${path}:${line} English locale must not repeat keys`);
-    for (const code of codes) {
-        const localized = getProperty(node, code);
-        assert.equal(ts.isObjectLiteralExpression(localized), true, `${path}:${line} ${code} locale must be an object`);
-        const localizedKeys = localized.properties.map(getPropertyName);
-        assert.deepEqual([...localizedKeys].sort(), [...keys].sort(), `${path}:${line} ${code} locale keys must match English`);
-        for (const key of keys) {
-            const localizedText = getProperty(localized, key);
-            assertText(localizedText, `${path}:${line} ${code}.${key}`);
-            if (placeholderKeys.has(`${path}:${key}`)) {
-                assert.equal(localizedText.text.includes('?'), true, `${path}:${line} ${code}.${key} must retain its ? placeholder`);
-            }
-        }
-    }
-}
-
-const taskConfig = JSON.parse(await readFile(new URL('../dist/app/task/config.json', import.meta.url), 'utf8'));
-assert.deepEqual(Object.values(taskConfig.locales), codes, 'task app config must load all 16 locales in registry order');
-for (const code of codes) {
-    assert.equal(taskConfig.locales[`/package/locale/${code}`], code, `task app must map /package/locale/${code}`);
-}
-const englishTaskLocale = JSON.parse(await readFile(new URL('../dist/app/task/locale/en.json', import.meta.url), 'utf8'));
-const taskKeys = Object.keys(englishTaskLocale).sort();
-for (const code of codes) {
-    const locale = JSON.parse(await readFile(new URL(`../dist/app/task/locale/${code}.json`, import.meta.url), 'utf8'));
-    assert.deepEqual(Object.keys(locale).sort(), taskKeys, `task app ${code}.json keys must match en.json`);
-    for (const [key, value] of Object.entries(locale)) {
-        assert.equal(typeof value, 'string', `task app ${code}.json ${key} must be a string`);
-        assert.notEqual(value.trim(), '', `task app ${code}.json ${key} must not be empty`);
-    }
-}
-
-const demoTaskLayout = await readFile(new URL('../dist/app/demo/form/method/task/task.xml', import.meta.url), 'utf8');
-const demoLocaleData = demoTaskLayout.match(/<label>Change global locale lang:<\/label>\s*<layout[^>]*>\s*<select[^>]*:data="\[([^"]+)\]"/)?.[1];
-assert.ok(demoLocaleData, 'demo Library task form must retain the global locale selector');
-const demoLocaleCodes = [...demoLocaleData.matchAll(/'([^']+)'/g)].map((match) => match[1]);
-assert.deepEqual(demoLocaleCodes, codes, 'demo global locale selector must expose all 16 locales in registry order');
-
-dom.window.close();
-console.log(`Locale registry, ${tables.length} TypeScript tables, 16 task app locale JSON files and the Demo selector are complete.`);

package/test/pop-max-size.mjs

@@ -1,66 +0,0 @@
-// Run: node --experimental-vm-modules test/pop-max-size.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><style>.pop { max-width: 480px; max-height: 300px; }</style><div id="trigger"></div><div class="pop"></div>');
-for (const name of ['window', 'document', 'Element', 'HTMLElement', 'PointerEvent']) {
-    Object.defineProperty(globalThis, name, {
-        'configurable': true,
-        'value': dom.window[name],
-    });
-}
-globalThis.getComputedStyle = dom.window.getComputedStyle.bind(dom.window);
-Object.defineProperty(window, 'innerWidth', { 'configurable': true, 'value': 1024 });
-Object.defineProperty(window, 'innerHeight', { 'configurable': true, 'writable': true, 'value': 768 });
-
-let refreshSize;
-const domModule = new SyntheticModule(['findParentByData', 'watchSize'], function() {
-    this.setExport('findParentByData', () => null);
-    this.setExport('watchSize', (_id, _pop, callback) => { refreshSize = callback; });
-});
-const toolModule = new SyntheticModule(['sleep'], function() {
-    this.setExport('sleep', () => Promise.resolve());
-});
-const empty = new SyntheticModule([], function() {});
-const source = await readFile(new URL('../dist/lib/form.ts', import.meta.url), 'utf8');
-const formModule = new SourceTextModule(ts.transpileModule(source, {
-    'compilerOptions': {
-        'target': ts.ScriptTarget.ES2022,
-        'module': ts.ModuleKind.ESNext,
-    },
-}).outputText);
-await formModule.link((specifier) => {
-    if (specifier === './dom') {
-        return domModule;
-    }
-    if (specifier === './tool') {
-        return toolModule;
-    }
-    return empty;
-});
-await formModule.evaluate();
-
-const trigger = document.querySelector('#trigger');
-const pop = document.querySelector('.pop');
-formModule.namespace.showPop(trigger, pop, 'v', { 'autoPosition': true });
-await Promise.resolve();
-assert.equal(pop.style.maxHeight, 'min(300px, 760px)', 'CSS max-height must survive the viewport limit');
-assert.equal(pop.style.maxWidth, 'min(480px, 1016px)', 'CSS max-width must survive the viewport limit');
-
-window.innerHeight = 240;
-refreshSize();
-assert.equal(pop.style.maxHeight, 'min(300px, 232px)', 'a smaller viewport must still constrain the popup');
-
-pop.style.maxHeight = '180px';
-refreshSize();
-assert.equal(pop.style.maxHeight, 'min(180px, 232px)', 'an explicit inline limit must take effect');
-
-pop.style.maxHeight = '';
-refreshSize();
-assert.equal(pop.style.maxHeight, 'min(300px, 232px)', 'removing an inline limit must restore the CSS limit');
-
-dom.window.close();
-console.log('Popup CSS limits, viewport limits, and inline overrides passed.');