367 lines
22 KiB
JavaScript
367 lines
22 KiB
JavaScript
import assert from 'node:assert/strict'
|
|
import { test } from 'node:test'
|
|
import { createRequire } from 'node:module'
|
|
import { readFileSync } from 'node:fs'
|
|
import { fileURLToPath } from 'node:url'
|
|
import { runInNewContext } from 'node:vm'
|
|
|
|
const require = createRequire(new URL('../01_content/package.json', import.meta.url))
|
|
const { buildSync, transformSync } = require('esbuild')
|
|
function sourceModule(relative) {
|
|
const code = buildSync({ entryPoints: [fileURLToPath(new URL(relative, import.meta.url))], bundle: true, write: false, platform: 'node', format: 'cjs' }).outputFiles[0].text
|
|
const module = { exports: {} }
|
|
runInNewContext(code, { module, exports: module.exports })
|
|
return module.exports
|
|
}
|
|
const { WidgetMountRegistry, widgetManifestPath, widgetTargets, newWidgetId, WIDGET_BINDINGS_KEY } = sourceModule('../01_content/src/client/widgetMount.ts')
|
|
const paths = sourceModule('../01_content/src/client/pathutil.ts')
|
|
const indexSource = readFileSync(new URL('../01_content/src/client/index.tsx', import.meta.url), 'utf8').replace(/\r\n/g, '\n')
|
|
const splitSource = readFileSync(new URL('../01_content/src/client/split.tsx', import.meta.url), 'utf8').replace(/\r\n/g, '\n')
|
|
function section(source, start, end) {
|
|
const a = source.indexOf(start), b = source.indexOf(end, a + start.length)
|
|
assert.ok(a >= 0 && b > a, 'source section missing: ' + start)
|
|
return source.slice(a, b)
|
|
}
|
|
function evaluate(code, bindings = {}) {
|
|
const module = { exports: {} }
|
|
runInNewContext(transformSync(code, { loader: 'tsx', format: 'cjs' }).code, { module, exports: module.exports, ...bindings })
|
|
return module.exports
|
|
}
|
|
function storage(seed = {}) {
|
|
const values = new Map(Object.entries(seed))
|
|
return { getItem: key => values.get(key) ?? null, setItem: (key, value) => values.set(key, value), values }
|
|
}
|
|
const specOf = id => ({ id, title: id, left: null, top: [{ id: 'p1', title: '窗口1', content: null }], main: [{ id: 'p2', title: '窗口2', content: null }] })
|
|
const resultOf = (b, extra = {}) => JSON.stringify({ version: 2, projectId: b.projectId, paneId: b.paneId, bindingId: b.bindingId, window: b.window, path: 'daily-station.html', kind: 'html', ...extra })
|
|
function registryFixture() {
|
|
const store = storage()
|
|
let next = 0
|
|
return { store, registry: new WidgetMountRegistry(store, () => 'binding-' + (++next)) }
|
|
}
|
|
|
|
test('new project in an old/shared folder has no auto-mount ownership', () => {
|
|
const { registry } = registryFixture()
|
|
const a = specOf('A'), b = specOf('B'), folder = 'C:/shared'
|
|
registry.begin('A', a, folder, 'S', '窗口1')
|
|
assert.equal(registry.entries('B').length, 0)
|
|
const ownedByA = registry.entries('A')[0]
|
|
assert.equal(registry.resolve(ownedByA, resultOf(ownedByA), b, folder), null)
|
|
assert.equal(b.top[0].content, null)
|
|
})
|
|
test('same folder and same display name still yield distinct project paths', () => {
|
|
const { registry } = registryFixture()
|
|
const a = specOf('A'), b = specOf('B')
|
|
a.title = b.title = '同名项目'
|
|
const aa = registry.begin('A', a, 'C:/shared', 'S', '窗口1')[0]
|
|
const bb = registry.begin('B', b, 'C:/shared', 'S', '窗口1')[0]
|
|
assert.notEqual(widgetManifestPath(aa), widgetManifestPath(bb))
|
|
assert.equal(registry.resolve(bb, resultOf(aa), b, 'C:/shared'), null)
|
|
})
|
|
test('raw legacy object/array never authorizes a current result', () => {
|
|
const { registry } = registryFixture(), spec = specOf('A')
|
|
const b = registry.begin('A', spec, '/shared', 'S', '窗口1')[0]
|
|
for (const raw of ['{"window":"窗口1","kind":"html","path":"old.html"}', '[{"window":"窗口1","path":"old.html"}]']) {
|
|
assert.equal(registry.resolve(b, raw, spec, '/shared'), null)
|
|
}
|
|
})
|
|
test('ownership, window, kind and malformed JSON are checked independently', () => {
|
|
const { registry } = registryFixture(), spec = specOf('A')
|
|
const b = registry.begin('A', spec, '/shared', 'S', '窗口1')[0]
|
|
for (const extra of [{ version: 1 }, { projectId: 'B' }, { paneId: 'missing' }, { bindingId: 'old' }, { window: '窗口99' }, { kind: 'unknown' }, { path: '' }]) {
|
|
assert.equal(registry.resolve(b, resultOf(b, extra), spec, '/shared'), null)
|
|
}
|
|
assert.equal(registry.resolve(b, '{bad', spec, '/shared'), null)
|
|
assert.ok(registry.resolve(b, resultOf(b), spec, '/shared'))
|
|
})
|
|
test('refresh restores valid ownership and independent multi-window bindings', () => {
|
|
const { registry, store } = registryFixture(), spec = specOf('A')
|
|
const entries = registry.begin('A', spec, 'C:/shared', 'S', '窗口1')
|
|
assert.equal(entries.length, 2)
|
|
assert.notEqual(widgetManifestPath(entries[0]), widgetManifestPath(entries[1]))
|
|
const restored = new WidgetMountRegistry(store)
|
|
for (const b of entries) assert.ok(restored.resolve(b, resultOf(b), spec, 'C:/shared'))
|
|
assert.ok(store.values.has(WIDGET_BINDINGS_KEY))
|
|
})
|
|
test('re-customizing one pane rejects its old writer without canceling another pane', () => {
|
|
const { registry } = registryFixture(), spec = specOf('A')
|
|
const old = registry.begin('A', spec, '/shared', 'S1', '窗口1')
|
|
const next = registry.begin('A', spec, '/shared', 'S2', '窗口1')
|
|
assert.notEqual(widgetManifestPath(old[0]), widgetManifestPath(next[0]))
|
|
assert.equal(registry.resolve(old[0], resultOf(old[0]), spec, '/shared'), null)
|
|
assert.ok(registry.resolve(old[1], resultOf(old[1]), spec, '/shared'))
|
|
})
|
|
test('manual revocation survives reload and an unrelated custom task', () => {
|
|
const { registry, store } = registryFixture(), spec = specOf('A')
|
|
const old = registry.begin('A', spec, '/shared', 'S', '窗口1')
|
|
registry.revokePane('A', 'p1')
|
|
const restored = new WidgetMountRegistry(store, () => 'binding-new')
|
|
restored.begin('A', spec, '/shared', 'S', '窗口2')
|
|
assert.equal(restored.entries('A').some(b => b.paneId === 'p1'), false)
|
|
assert.equal(restored.resolve(old[0], resultOf(old[0]), spec, '/shared'), null)
|
|
})
|
|
test('another session receives only its own window bindings in the real task prompt', () => {
|
|
const { registry } = registryFixture(), spec = specOf('A')
|
|
const first = registry.begin('A', spec, '/shared', 'S1', '窗口1')
|
|
const second = registry.begin('A', spec, '/shared', 'S2', '窗口2')
|
|
const build = evaluate(section(indexSource, 'function buildWindowTaskText(', '\n/** 自定义窗口任务') + '\nexport { buildWindowTaskText }', { KNOWLEDGE_PACK: 'generic knowledge', widgetManifestPath }).buildWindowTaskText
|
|
const prompt = build('A', '项目 A', '窗口2', 'widget', '/shared', 'send', second)
|
|
assert.deepEqual(Array.from(second, b => b.sessionId), ['S2'])
|
|
assert.ok(prompt.includes(widgetManifestPath(second[0])))
|
|
assert.ok(!prompt.includes(widgetManifestPath(first[0])))
|
|
assert.ok(registry.resolve(first[0], resultOf(first[0]), spec, '/shared'))
|
|
})
|
|
test('changing directory or removing target makes a previously valid result invalid', () => {
|
|
const { registry } = registryFixture(), spec = specOf('A')
|
|
const b = registry.begin('A', spec, '/shared', 'S', '窗口1')[0]
|
|
assert.equal(registry.resolve(b, resultOf(b), spec, '/other'), null)
|
|
assert.equal(registry.resolve(b, resultOf(b), { ...spec, top: [] }, '/shared'), null)
|
|
registry.revokeProject('A')
|
|
assert.equal(registry.resolve(b, resultOf(b), spec, '/shared'), null)
|
|
})
|
|
test('moved panes resolve by stable id rather than their previous row/index', () => {
|
|
const { registry } = registryFixture(), spec = specOf('A')
|
|
const b = registry.begin('A', spec, '/shared', 'S', '窗口1')[0]
|
|
const moved = { ...spec, top: [spec.main[0]], main: [spec.top[0]] }
|
|
const resolved = registry.resolve(b, resultOf(b), moved, '/shared')
|
|
assert.equal(resolved.target.row, 'main')
|
|
assert.equal(resolved.target.pane.id, 'p1')
|
|
})
|
|
test('storage failure prevents sending with a nonpersistent new binding', () => {
|
|
const registry = new WidgetMountRegistry({ getItem: () => null, setItem() { throw new Error('quota') } }, () => 'binding-test')
|
|
assert.throws(() => registry.begin('A', specOf('A'), '/shared', 'S', '窗口1'), /quota/)
|
|
assert.equal(registry.entries().length, 0)
|
|
})
|
|
test('project ids are independent even when generated within one clock tick', () => {
|
|
assert.equal(new Set(Array.from({ length: 100 }, () => newWidgetId('layout'))).size, 100)
|
|
})
|
|
|
|
// Execute the real async loader and real lockPane method, not a reimplementation.
|
|
function mountingFixture() {
|
|
const { registry, store } = registryFixture()
|
|
const specs = { A: specOf('A'), B: specOf('B') }, folders = { A: 'C:/shared', B: 'C:/shared' }
|
|
const lockMethod = section(splitSource, ' lockPane(row, i, content) {', '\n /** 更新指定标签页')
|
|
const splitStore = evaluate('const splitStore = { active: true, spec: null, onSpecMutated: null, persist() {}, notify() {}, ' + lockMethod + ' }; export { splitStore }', { tabTitleOf: c => c.title }).splitStore
|
|
splitStore.spec = specs.A
|
|
splitStore.onSpecMutated = s => { specs[s.id] = s }
|
|
const calls = [], reads = [], files = new Map()
|
|
const lock = splitStore.lockPane
|
|
splitStore.lockPane = function (...args) { calls.push(args); lock.apply(this, args) }
|
|
const pendingMountRef = { current: {} }, mountedWidgetRef = { current: {} }, mountedRef = { current: true }
|
|
const mountContent = evaluate(section(indexSource, 'function buildMountContent(', '\n/** 每会话最近观察') + '\nexport { buildMountContent }', paths).buildMountContent
|
|
const bindings = {
|
|
useCallback: fn => fn, widgetRegistry: registry,
|
|
widgetProjectOf: id => ({ folder: folders[id], spec: splitStore.active && splitStore.spec?.id === id ? splitStore.spec : specs[id] }),
|
|
widgetManifestPath, mountedRef, mountedWidgetRef, pendingMountRef, widgetReadSeqRef: { current: {} }, splitStore, buildMountContent: mountContent,
|
|
recordMountedWidget: (id, raw) => { mountedWidgetRef.current[id] = raw }, persistPendingWidgets() {},
|
|
async fetch(url) {
|
|
const path = new URL(url, 'http://fixture').searchParams.get('path')
|
|
reads.push(path)
|
|
const value = files.get(path)
|
|
return value ? { ok: true, text: typeof value === 'function' ? value : async () => value } : { ok: false }
|
|
},
|
|
}
|
|
const apply = evaluate(section(indexSource, ' const applyWidgetManifest = useCallback(', '\n // 完成边沿') + '\nexport { applyWidgetManifest }', bindings).applyWidgetManifest
|
|
return { registry, store, specs, folders, splitStore, calls, reads, files, pendingMountRef, mountedWidgetRef, mountedRef, apply }
|
|
}
|
|
test('actual loader never reads the root legacy file and cannot mount project A in B', async () => {
|
|
const f = mountingFixture(), b = f.registry.begin('A', f.specs.A, f.folders.A, 'S', '窗口1')[0]
|
|
f.files.set('C:/shared/widget-result.json', '{"window":"窗口1","path":"old.html"}')
|
|
f.files.set(widgetManifestPath(b), resultOf(b))
|
|
f.splitStore.spec = f.specs.B
|
|
await f.apply(b, null)
|
|
assert.equal(f.calls.length, 0)
|
|
assert.ok(f.pendingMountRef.current[b.bindingId])
|
|
assert.equal(f.specs.B.top[0].content, null)
|
|
assert.deepEqual(f.reads, [widgetManifestPath(b)])
|
|
})
|
|
test('actual loader blocks wrong identity and nonexistent window rather than falling back to window1', async () => {
|
|
const f = mountingFixture(), b = f.registry.begin('A', f.specs.A, f.folders.A, 'S', '窗口1')[0]
|
|
await f.apply(b, resultOf(b, { projectId: 'B' }))
|
|
await f.apply(b, resultOf(b, { window: '窗口99' }))
|
|
assert.equal(f.calls.length, 0)
|
|
})
|
|
test('a next completion reloads the same HTML even when the manifest text is unchanged', async () => {
|
|
const f = mountingFixture(), b = f.registry.begin('A', f.specs.A, f.folders.A, 'S', '窗口1')[0]
|
|
const raw = resultOf(b)
|
|
await f.apply(b, raw)
|
|
const firstTab = f.splitStore.spec.top[0].tabs[0].id
|
|
await f.apply(b, raw)
|
|
assert.equal(f.calls.length, 1)
|
|
await f.apply(b, raw, true)
|
|
assert.equal(f.calls.length, 2)
|
|
assert.notEqual(f.splitStore.spec.top[0].tabs[0].id, firstTab)
|
|
})
|
|
test('old reads finishing after rebind, directory change or manual replacement cannot overwrite a pane', async () => {
|
|
for (const action of ['rebind', 'folder', 'manual', 'unmount']) {
|
|
const f = mountingFixture(), b = f.registry.begin('A', f.specs.A, f.folders.A, 'S', '窗口1')[0]
|
|
let finish
|
|
const waiting = new Promise(resolve => { finish = resolve })
|
|
f.files.set(widgetManifestPath(b), () => waiting)
|
|
const loading = f.apply(b, null)
|
|
await Promise.resolve()
|
|
if (action === 'rebind') f.registry.begin('A', f.specs.A, f.folders.A, 'S2', '窗口1')
|
|
if (action === 'folder') f.folders.A = 'C:/other'
|
|
if (action === 'manual') f.registry.revokePane('A', b.paneId)
|
|
if (action === 'unmount') f.mountedRef.current = false
|
|
finish(resultOf(b))
|
|
await loading
|
|
assert.equal(f.calls.length, 0, action)
|
|
}
|
|
})
|
|
test('pending result is revalidated after refresh/move and rejected after manual close', async () => {
|
|
const f = mountingFixture(), b = f.registry.begin('A', f.specs.A, f.folders.A, 'S', '窗口1')[0]
|
|
f.splitStore.active = false
|
|
await f.apply(b, resultOf(b))
|
|
const pending = f.pendingMountRef.current[b.bindingId]
|
|
f.files.set(widgetManifestPath(b), resultOf(b))
|
|
f.splitStore.active = true
|
|
f.splitStore.spec = { ...f.specs.A, top: [f.specs.A.main[0]], main: [f.specs.A.top[0]] }
|
|
await f.apply(pending.binding, null, true)
|
|
assert.equal(f.calls[0][0], 'main')
|
|
f.registry.revokePane('A', 'p1')
|
|
await f.apply(pending.binding, null, true)
|
|
assert.equal(f.calls.length, 1)
|
|
})
|
|
test('loading legacy project state preserves its saved windows without using old pending', () => {
|
|
const saved = specOf('old')
|
|
saved.top[0].tabs = [{ id: 'old-tab', content: { kind: 'iframe', url: 'old.html' } }]
|
|
const store = storage({ 'dsh.worktable.projects.v1': JSON.stringify({ layouts: [saved], folders: { old: 'C:/shared' } }), 'dsh.worktable.pendingMount.v1': JSON.stringify({ fresh: { content: 'old.html' } }) })
|
|
const load = evaluate(section(indexSource, 'function loadProjects()', '\nconst clamp') + '\nexport { loadProjects }', { localStorage: store, PROJECTS_KEY: 'dsh.worktable.projects.v1', DEFAULT_PROJECTS: {} }).loadProjects
|
|
assert.equal(load().layouts[0].top[0].tabs[0].content.url, 'old.html')
|
|
assert.equal(new WidgetMountRegistry(store).entries().length, 0)
|
|
assert.ok(!indexSource.includes("getItem('dsh.worktable.pendingMount.v1')"))
|
|
})
|
|
test('real project opening retains failed pending reads and retries on the next open', async () => {
|
|
for (const failure of ['http', 'read']) {
|
|
const f = mountingFixture(), b = f.registry.begin('A', f.specs.A, f.folders.A, 'S', '窗口1')[0]
|
|
f.splitStore.active = false
|
|
await f.apply(b, resultOf(b))
|
|
f.splitStore.open = spec => { f.splitStore.active = true; f.splitStore.spec = spec }
|
|
if (failure === 'read') f.files.set(widgetManifestPath(b), async () => { throw new Error('read failed') })
|
|
const open = evaluate(section(indexSource, ' const openSplit = useCallback(', '\n /** 打开「工作台」控制室') + '\nexport { openSplit }', {
|
|
useCallback: fn => fn, engineIdsRef: { current: new Set() }, projects: { views: {} }, splitStore: f.splitStore,
|
|
currentSessionOf: () => null, sessionBridge: null, projectAttachRef: {}, projectsRef: { current: { projects: { bindings: {} } } },
|
|
ackProjectNotify() {}, pendingMountRef: f.pendingMountRef, applyWidgetManifest: f.apply, persistPendingWidgets() {},
|
|
}).openSplit
|
|
open(f.specs.A)
|
|
await new Promise(resolve => setImmediate(resolve))
|
|
assert.equal(f.calls.length, 0, failure)
|
|
assert.ok(f.pendingMountRef.current[b.bindingId], failure + ' keeps retry record')
|
|
f.splitStore.active = false
|
|
f.files.set(widgetManifestPath(b), resultOf(b))
|
|
open(f.specs.A)
|
|
await new Promise(resolve => setImmediate(resolve))
|
|
assert.equal(f.calls.length, 1, failure)
|
|
assert.equal(f.pendingMountRef.current[b.bindingId], undefined, failure + ' clears only on success')
|
|
}
|
|
})
|
|
|
|
test('actual startup sweep ignores every unregistered project, even with a legacy result in its folder', async () => {
|
|
const f = mountingFixture()
|
|
f.files.set('C:/shared/widget-result.json', '{"window":"窗口1","path":"old.html","kind":"html"}')
|
|
const effects = []
|
|
evaluate(section(indexSource, ' // 只扫描已明确登记', '\n /** 收集某会话') + '\nexport {}', {
|
|
useEffect: fn => effects.push(fn), projects: { folders: f.folders }, widgetTick: 0, widgetRegistry: f.registry, applyWidgetManifest: f.apply,
|
|
})
|
|
effects[0]()
|
|
await new Promise(resolve => setImmediate(resolve))
|
|
assert.deepEqual(f.reads, [])
|
|
assert.equal(f.calls.length, 0)
|
|
})
|
|
test('actual completion effect processes both projects sharing one session and supports the next round', async () => {
|
|
const f = mountingFixture()
|
|
const aa = f.registry.begin('A', f.specs.A, f.folders.A, 'S', '窗口1')[0]
|
|
const bb = f.registry.begin('B', f.specs.B, f.folders.B, 'S', '窗口1')[0]
|
|
f.files.set(widgetManifestPath(aa), resultOf(aa))
|
|
f.files.set(widgetManifestPath(bb), resultOf(bb))
|
|
const effects = [], snapshot = { snapshot: { byId: { S: { completed: true } } } }
|
|
evaluate(section(indexSource, ' // 完成边沿只触发读取', '\n // 只扫描已明确登记') + '\nexport {}', {
|
|
useEffect: fn => effects.push(fn), sessionsSnapshotStore: snapshot, widgetRegistry: f.registry, projects: { bindings: { A: 'S', B: 'S' } },
|
|
doneSeenRef: { current: {} }, clearNotifyAck() {}, mountConsumedRef: { current: new Set() }, applyWidgetManifest: f.apply, notifyTick: 0, widgetTick: 0,
|
|
})
|
|
effects[0]()
|
|
await new Promise(resolve => setImmediate(resolve))
|
|
assert.equal(f.calls.length, 1)
|
|
assert.ok(f.pendingMountRef.current[bb.bindingId])
|
|
const firstTab = f.splitStore.spec.top[0].tabs[0].id
|
|
effects[0]()
|
|
await new Promise(resolve => setImmediate(resolve))
|
|
assert.equal(f.calls.length, 1)
|
|
snapshot.snapshot.byId.S.completed = false
|
|
effects[0]()
|
|
snapshot.snapshot.byId.S.completed = true
|
|
effects[0]()
|
|
await new Promise(resolve => setImmediate(resolve))
|
|
assert.equal(f.calls.length, 2)
|
|
assert.notEqual(f.splitStore.spec.top[0].tabs[0].id, firstTab)
|
|
})
|
|
test('a slower earlier read cannot overwrite a newer result from the same binding', async () => {
|
|
const f = mountingFixture(), b = f.registry.begin('A', f.specs.A, f.folders.A, 'S', '窗口1')[0]
|
|
let finishOld
|
|
f.files.set(widgetManifestPath(b), () => new Promise(resolve => { finishOld = resolve }))
|
|
const oldRead = f.apply(b, null, true)
|
|
await Promise.resolve()
|
|
f.files.set(widgetManifestPath(b), resultOf(b, { path: 'new.html' }))
|
|
await f.apply(b, null, true)
|
|
finishOld(resultOf(b, { path: 'old.html' }))
|
|
await oldRead
|
|
assert.equal(f.calls.length, 1)
|
|
assert.equal(f.splitStore.spec.top[0].tabs[0].content.title, 'new.html')
|
|
})
|
|
test('completion of one session never reads or reloads another session window in the same project', async () => {
|
|
const f = mountingFixture()
|
|
const first = f.registry.begin('A', f.specs.A, f.folders.A, 'S1', '窗口1')[0]
|
|
f.registry.begin('A', f.specs.A, f.folders.A, 'S2', '窗口2')
|
|
const second = f.registry.entries('A').find(b => b.sessionId === 'S2')
|
|
f.files.set(widgetManifestPath(first), resultOf(first))
|
|
f.files.set(widgetManifestPath(second), resultOf(second))
|
|
await f.apply(first, resultOf(first))
|
|
const firstTab = f.splitStore.spec.top[0].tabs[0].id
|
|
const effects = [], snapshot = { snapshot: { byId: { S1: { completed: false }, S2: { completed: true } } } }
|
|
evaluate(section(indexSource, ' // 完成边沿只触发读取', '\n // 只扫描已明确登记') + '\nexport {}', {
|
|
useEffect: fn => effects.push(fn), sessionsSnapshotStore: snapshot, widgetRegistry: f.registry, projects: { bindings: { A: 'S2' } },
|
|
doneSeenRef: { current: {} }, clearNotifyAck() {}, mountConsumedRef: { current: new Set() }, applyWidgetManifest: f.apply, notifyTick: 0, widgetTick: 0,
|
|
})
|
|
effects[0]()
|
|
await new Promise(resolve => setImmediate(resolve))
|
|
assert.deepEqual(f.reads, [widgetManifestPath(second)])
|
|
assert.equal(f.splitStore.spec.top[0].tabs[0].id, firstTab)
|
|
assert.equal(f.calls.length, 2)
|
|
snapshot.snapshot.byId.S1.completed = true
|
|
effects[0]()
|
|
await new Promise(resolve => setImmediate(resolve))
|
|
assert.equal(f.calls.length, 3)
|
|
assert.notEqual(f.splitStore.spec.top[0].tabs[0].id, firstTab)
|
|
})
|
|
test('real closeTab revokes ownership before saving the empty window', async () => {
|
|
const f = mountingFixture(), b = f.registry.begin('A', f.specs.A, f.folders.A, 'S', '窗口1')[0]
|
|
await f.apply(b, resultOf(b))
|
|
const method = evaluate('const close = { ' + section(splitSource, ' closeTab(row, i, tabId) {', '\n moveTab(') + ' }; export { close }').close.closeTab
|
|
f.splitStore.onPaneContentEdited = (id, paneId) => f.registry.revokePane(id, paneId)
|
|
method.call(f.splitStore, 'top', 0, f.splitStore.spec.top[0].tabs[0].id)
|
|
assert.equal(f.splitStore.spec.top[0].tabs.length, 0)
|
|
await f.apply(b, resultOf(b), true)
|
|
assert.equal(f.calls.length, 1)
|
|
})
|
|
test('actual new-layout builder keeps both projects empty and independently identified', () => {
|
|
const build = evaluate(section(indexSource, 'function buildLayout(', '\n/** 布局缩略图') + '\nexport { buildLayout }', {
|
|
PRESET_DEFS: [{ id: 'grid', leftCount: 0, topCount: 2, contentCount: 1 }], newWidgetId,
|
|
}).buildLayout
|
|
const a = build('grid', 'A'), b = build('grid', 'B')
|
|
assert.notEqual(a.id, b.id)
|
|
a.top[0].content = { kind: 'iframe', url: 'old.html' }
|
|
assert.equal(b.top[0].content, null)
|
|
assert.equal(b.main[0].content, null)
|
|
})
|
|
test('actual task prompt uses only this project binding paths and preserves follow-up instructions', () => {
|
|
const { registry } = registryFixture(), spec = specOf('A')
|
|
const owned = registry.begin('A', spec, 'C:/shared', 'S', '窗口1')
|
|
registry.begin('B', specOf('B'), 'C:/shared', 'S', '窗口1')
|
|
const build = evaluate(section(indexSource, 'function buildWindowTaskText(', '\n/** 自定义窗口任务') + '\nexport { buildWindowTaskText }', { KNOWLEDGE_PACK: 'generic knowledge', widgetManifestPath }).buildWindowTaskText
|
|
const prompt = build('A', '项目 A', '窗口1', 'new widget', 'C:/shared', 'send', owned)
|
|
for (const b of owned) assert.ok(prompt.includes(widgetManifestPath(b)))
|
|
assert.ok(prompt.includes('继续修改同名作品'))
|
|
assert.ok(!prompt.includes('project-B'))
|
|
assert.ok(prompt.includes('不读写项目根目录旧的 widget-result.json'))
|
|
})
|