import type { FormulaControlSnapshot, TemplateAnnotationApiContext, TemplateAnnotationClient } from '../api/template-annotation';
|
import type { PluginContext } from '../domain/plugin-context';
|
import type {
|
TemplateBinding,
|
TemplateChangeCheck,
|
TemplateControlSnapshot,
|
CrossTemplateScalarCandidate,
|
CrossTemplateSourceTemplate,
|
TemplateFieldOption,
|
TemplateCheckboxGroup,
|
TemplateCheckboxGroupDraft,
|
TemplatePrivateFieldDraft,
|
TemplateRepairContext,
|
TemplateRepeatGroup,
|
TemplateStepConfiguration,
|
} from '../domain/types';
|
import type { OnlyOfficeBridge } from '../onlyoffice/bridge';
|
import type {
|
FormulaBindingLockSnapshot,
|
FormulaBindingRequest,
|
FormulaResultLockSnapshot,
|
TemplateFormulaBinding,
|
TemplateFormulaVersion,
|
} from '../domain/formula-mapping';
|
|
import { TemplateAnnotationApiError, templateAnnotationClient } from '../api/template-annotation';
|
import { ref } from 'vue';
|
import { generateOpaqueId } from '../domain/tags';
|
import { buildFormulaBindingRequest } from '../domain/formula-mapping';
|
import { toTemplateFieldOptions } from '../domain/types';
|
import { useAnnotationStore } from '../stores/annotation';
|
import { usePluginContextStore } from '../stores/plugin-context';
|
|
const SDK_READY_TIMEOUT_MS = 5_000;
|
|
function message(error: unknown): string {
|
return error instanceof Error ? error.message : String(error);
|
}
|
function countTag(controls: Array<{ Tag?: string }>, tag: string): number {
|
return controls.filter((item) => item.Tag === tag).length;
|
}
|
function isExpiredTicket(error: unknown): boolean {
|
return error instanceof TemplateAnnotationApiError && (error.status === 401 || error.status === 403);
|
}
|
function isCrossTemplateReadOnlyBinding(binding: TemplateBinding): boolean {
|
return binding.readOnly === true && binding.valueSource === 'CROSS_TEMPLATE';
|
}
|
|
class FormulaConfirmAmbiguousError extends Error {
|
constructor() {
|
super('公式升级确认状态待确认，请刷新后继续');
|
}
|
}
|
|
export function useTemplateAnnotator(bridge: OnlyOfficeBridge, client: TemplateAnnotationClient = templateAnnotationClient) {
|
const store = useAnnotationStore();
|
const contextStore = usePluginContextStore();
|
const bindingState = ref<TemplateBinding[]>([]);
|
const fieldState = ref<TemplateFieldOption[]>([]);
|
const checkboxGroupState = ref<TemplateCheckboxGroup[]>([]);
|
const crossTemplateScalarCandidateState = ref<CrossTemplateScalarCandidate[]>([]);
|
const crossTemplateSourceTemplateState = ref<CrossTemplateSourceTemplate[]>([]);
|
const repeatGroupState = ref<TemplateRepeatGroup[]>([]);
|
const stepConfigurationState = ref<null | TemplateStepConfiguration>(null);
|
const currentStepIdState = ref<null | string>(null);
|
const formulaBindingState = ref<TemplateFormulaBinding[]>([]);
|
const formulaVersionState = ref<TemplateFormulaVersion[]>([]);
|
const pendingRepair = ref<null | TemplateRepairContext>(null);
|
let disposed = false;
|
let inFlight = false;
|
let instanceContext: null | PluginContext = null;
|
let readyTimeout: ReturnType<typeof setTimeout> | undefined;
|
let trackRevisionsDisabled = false;
|
let trackRevisionsPreparation: Promise<void> | undefined;
|
const abortController = new AbortController();
|
const pendingCheckedChanges = new Map<string, TemplateChangeCheck>();
|
let pendingRepairConfirmation: null | TemplateRepairContext = null;
|
|
function apiContext(): TemplateAnnotationApiContext {
|
if (disposed || !instanceContext?.ticket) throw new Error('插件运行上下文不可用');
|
return { apiBaseUrl: instanceContext.apiBaseUrl, ticket: instanceContext.ticket, signal: abortController.signal };
|
}
|
|
function setWorking(text: string, initializing = false): void {
|
if (disposed) return;
|
store.setStatus(initializing ? 'initializing' : 'working');
|
store.setOperation({ kind: 'working', message: text });
|
}
|
|
function clearReadyTimeout(): void {
|
if (readyTimeout !== undefined) clearTimeout(readyTimeout);
|
readyTimeout = undefined;
|
}
|
|
async function prepareDocumentMutation(): Promise<void> {
|
if (trackRevisionsDisabled) return;
|
if (!trackRevisionsPreparation) {
|
trackRevisionsPreparation = bridge
|
.disableTrackRevisions()
|
.then(() => {
|
if (!disposed) trackRevisionsDisabled = true;
|
})
|
.finally(() => {
|
trackRevisionsPreparation = undefined;
|
});
|
}
|
await trackRevisionsPreparation;
|
}
|
|
function applyStepConfiguration(configuration: TemplateStepConfiguration): void {
|
stepConfigurationState.value = configuration;
|
if (configuration.singleStep) {
|
currentStepIdState.value = configuration.steps[0]?.id ?? null;
|
return;
|
}
|
if (!configuration.steps.some((step) => step.id === currentStepIdState.value)) currentStepIdState.value = null;
|
}
|
|
function requireCurrentStepId(): string {
|
if (currentStepIdState.value) return currentStepIdState.value;
|
if (stepConfigurationState.value?.singleStep) throw new Error('模板步骤配置无效');
|
throw new Error('多步骤模板必须选择当前步骤');
|
}
|
|
function setCurrentStepId(stepId: null | string): void {
|
if (stepId === null) {
|
currentStepIdState.value = null;
|
return;
|
}
|
if (!stepConfigurationState.value?.steps.some((step) => step.id === stepId)) throw new Error('当前步骤不存在');
|
currentStepIdState.value = stepId;
|
}
|
|
function expireTicket(error: unknown): void {
|
if (isExpiredTicket(error)) {
|
instanceContext = null;
|
contextStore.reset();
|
store.setStatus('error');
|
}
|
}
|
|
async function exclusive<T>(operation: () => Promise<T>): Promise<T> {
|
if (disposed) throw new Error('插件已关闭');
|
if (inFlight) throw new Error('已有操作正在执行');
|
if (!instanceContext) throw new Error('插件运行上下文不可用');
|
inFlight = true;
|
try {
|
return await operation();
|
} catch (error) {
|
if (!disposed) {
|
expireTicket(error);
|
if (!isExpiredTicket(error) && store.status === 'working') {
|
store.setStatus('ready');
|
store.setOperation({ kind: 'error', message: message(error) });
|
}
|
}
|
throw error;
|
} finally {
|
inFlight = false;
|
}
|
}
|
|
function bindingsForSnapshots(snapshots: TemplateControlSnapshot[]): TemplateBinding[] {
|
return snapshots.map((snapshot) => {
|
const current = bindingState.value.find((item) => item.id === snapshot.bindingId);
|
if (!current) throw new Error(`控件快照绑定不存在：${snapshot.bindingId}`);
|
return {
|
...current,
|
controlAlias: snapshot.controlAlias ?? current.controlAlias,
|
controlConfig: snapshot.controlConfig ?? current.controlConfig,
|
controlRole: snapshot.controlRole ?? current.controlRole,
|
controlTag: snapshot.controlTag,
|
controlType: snapshot.controlType ?? current.controlType,
|
fieldVersionId: snapshot.fieldVersionId ?? current.fieldVersionId,
|
primaryBindingId: snapshot.primaryBindingId ?? null,
|
};
|
});
|
}
|
|
function formulaResultBinding(formula: TemplateFormulaBinding, bindings = bindingState.value): TemplateBinding {
|
const result = bindings.find((item) => item.id === formula.resultBindingId && item.status === 'ACTIVE' && item.controlRole === 'PRIMARY');
|
if (!result) throw new Error('公式结果字段不存在或不是 ACTIVE 主字段');
|
return result;
|
}
|
|
function formulaResultControls(resultBindingId: string, lock: string, bindings = bindingState.value): FormulaControlSnapshot[] {
|
const primary = bindings.find((item) => item.id === resultBindingId && item.status === 'ACTIVE' && item.controlRole === 'PRIMARY');
|
if (!primary) throw new Error('公式结果字段不存在或不是 ACTIVE 主字段');
|
return [primary, ...bindings.filter((item) => item.status === 'ACTIVE' && item.controlRole === 'REFERENCE' && item.primaryBindingId === primary.id)].map(
|
(item) => ({ bindingId: item.id, controlTag: item.controlTag, controlRole: item.controlRole, lock }),
|
);
|
}
|
|
function expectedFormulaVersion(expectedVersions: Record<string, number>, bindingId: string): number {
|
const version = expectedVersions[bindingId];
|
if (typeof version !== 'number') throw new Error('公式映射预检版本缺失');
|
return version;
|
}
|
|
function formulaOriginalLockControls(
|
resultBindingId: string,
|
snapshot: FormulaResultLockSnapshot,
|
bindings = bindingState.value,
|
): FormulaBindingLockSnapshot[] {
|
const expected = formulaResultControls(resultBindingId, '', bindings);
|
const locksByTag = new Map(snapshot.locks.map((item) => [item.tag, item.lock]));
|
if (
|
snapshot.primaryTag !== expected[0]?.controlTag ||
|
locksByTag.size !== expected.length ||
|
snapshot.locks.length !== expected.length ||
|
expected.some((item) => !locksByTag.has(item.controlTag))
|
) {
|
throw new Error('公式结果锁快照与当前绑定不一致');
|
}
|
return expected.map((item) => ({ ...item, lock: locksByTag.get(item.controlTag)! }));
|
}
|
|
function savedFormulaResultLockSnapshot(formula: TemplateFormulaBinding, bindings = bindingState.value): FormulaResultLockSnapshot {
|
const saved = formula.jieguoSuoKuaizhao;
|
const expected = formulaResultControls(formula.resultBindingId, '', bindings);
|
if (!Array.isArray(saved)) throw new Error('公式 PENDING 缺少服务端原始锁快照');
|
const snapshots = new Map(saved.map((item) => [item.bindingId, item]));
|
if (
|
snapshots.size !== expected.length ||
|
saved.length !== expected.length ||
|
expected.some((item) => {
|
const snapshot = snapshots.get(item.bindingId);
|
return !snapshot || snapshot.controlTag !== item.controlTag || snapshot.controlRole !== item.controlRole || typeof snapshot.lock !== 'string';
|
})
|
) {
|
throw new Error('公式 PENDING 服务端原始锁快照不完整');
|
}
|
return {
|
primaryTag: expected[0]!.controlTag,
|
locks: expected.map((item) => ({ tag: item.controlTag, lock: snapshots.get(item.bindingId)!.lock })),
|
};
|
}
|
|
async function reconcilePendingFormulaBindings(formulas: TemplateFormulaBinding[], bindings: TemplateBinding[]): Promise<boolean> {
|
let needsReconciliation = false;
|
for (const formula of formulas.filter((item) => item.status === 'PENDING')) {
|
try {
|
const result = formulaResultBinding(formula, bindings);
|
if (await bridge.isFormulaResultLocked(result.controlTag)) {
|
await client.activateFormulaBinding(apiContext(), formula.id, {
|
controls: formulaResultControls(formula.resultBindingId, 'sdtContentLocked', bindings),
|
expectedVersion: formula.version,
|
operationCode: formula.operationCode,
|
});
|
formula.status = 'ACTIVE';
|
} else {
|
await prepareDocumentMutation();
|
if (disposed) return needsReconciliation;
|
await bridge.restoreFormulaResultLocks(savedFormulaResultLockSnapshot(formula, bindings));
|
await client.cancelFormulaBinding(apiContext(), formula.id, {
|
expectedVersion: formula.version,
|
operationCode: formula.operationCode,
|
reason: 'PENDING_LOCK_INCOMPLETE',
|
});
|
formula.status = 'CANCELLED';
|
}
|
} catch (error) {
|
if (isExpiredTicket(error)) throw error;
|
needsReconciliation = true;
|
store.setOperation({ kind: 'error', message: `公式待确认需对账：${message(error)}` });
|
}
|
}
|
return needsReconciliation;
|
}
|
|
async function reconcilePendingCrossTemplateBindings(bindings: TemplateBinding[], controls: Array<{ InternalId?: string; Lock?: string; Tag?: string }>): Promise<boolean> {
|
let needsReconciliation = false;
|
for (const binding of bindings.filter((item) => item.status === 'PENDING' && isCrossTemplateReadOnlyBinding(item))) {
|
try {
|
const matches = controls.filter((control) => control.Tag === binding.controlTag);
|
if (matches.length === 1 && matches[0]?.Lock === 'sdtContentLocked') {
|
await client.activateBinding(apiContext(), binding.id, { operationCode: generateOpaqueId('cross-template-reconcile') });
|
binding.status = 'ACTIVE';
|
continue;
|
}
|
if (matches.length > 1 || (matches.length === 1 && !matches[0]?.InternalId)) {
|
throw new Error('跨模板 PENDING 控件无法唯一恢复');
|
}
|
if (matches[0]?.InternalId) await bridge.deleteControl(matches[0].InternalId);
|
await client.cancelBinding(apiContext(), binding.id, {
|
operationCode: generateOpaqueId('cross-template-cancel'),
|
reason: 'PENDING_LOCK_INCOMPLETE',
|
});
|
binding.status = 'CANCELLED';
|
} catch (error) {
|
if (isExpiredTicket(error)) throw error;
|
needsReconciliation = true;
|
store.setOperation({ kind: 'error', message: `跨模板字段待确认需对账：${message(error)}` });
|
}
|
}
|
return needsReconciliation;
|
}
|
|
async function confirmCopiedFormulaBindings(
|
formulas: { bindings: TemplateFormulaBinding[]; copiedPendingBindingIds?: string[]; upgradeOperationCode?: string },
|
bindings: TemplateBinding[],
|
): Promise<void> {
|
const copiedIds = new Set(formulas.copiedPendingBindingIds ?? []);
|
if (!copiedIds.size) return;
|
if (!formulas.upgradeOperationCode) throw new Error('公式复制 PENDING 缺少升级操作码');
|
const copied = formulas.bindings.filter((item) => copiedIds.has(item.id));
|
if (copied.length !== copiedIds.size || copied.some((item) => item.status !== 'PENDING')) throw new Error('公式复制 PENDING 上下文不一致');
|
for (const formula of copied) {
|
const result = formulaResultBinding(formula, bindings);
|
if (!(await bridge.isFormulaResultLocked(result.controlTag))) throw new Error('公式复制结果控件未完整锁定');
|
}
|
await client.confirmFormulaVersionCopy(apiContext(), {
|
controls: copied.flatMap((item) => formulaResultControls(item.resultBindingId, 'sdtContentLocked', bindings)),
|
expectedVersions: Object.fromEntries(copied.map((item) => [item.id, item.version])),
|
upgradeOperationCode: formulas.upgradeOperationCode,
|
});
|
formulas.bindings = formulas.bindings.map((item) => (copiedIds.has(item.id) ? { ...item, status: 'ACTIVE' } : item));
|
}
|
|
function confirmation(check: TemplateChangeCheck, controls: Array<{ Tag?: string }>) {
|
return {
|
operationCode: check.operationCode,
|
expectedVersions: check.expectedVersions,
|
controls: bridge.snapshotControls(bindingsForSnapshots(check.controls), controls),
|
observedControlTags: controls.flatMap((control) => (typeof control.Tag === 'string' && control.Tag.trim().length > 0 ? [control.Tag] : [])),
|
};
|
}
|
|
async function locateControl(controls: Array<{ InternalId?: string; Tag?: string }>, locateTag: string): Promise<void> {
|
const matches = controls.filter((item) => item.Tag === locateTag);
|
if (matches.length === 0) throw new Error(`定位目标 Tag 不存在：${locateTag}`);
|
if (matches.length > 1) throw new Error(`定位目标 Tag 出现多次：${locateTag}`);
|
if (!matches[0]?.InternalId) throw new Error(`定位目标控件缺少 InternalId：${locateTag}`);
|
await bridge.selectControl(matches[0].InternalId, abortController.signal);
|
}
|
|
async function confirmCopiedBindings(
|
context: Awaited<ReturnType<TemplateAnnotationClient['fetchAnnotationContext']>>,
|
formulas: Awaited<ReturnType<TemplateAnnotationClient['fetchFormulaMappings']>>,
|
controls: Array<{ Tag?: string }>,
|
): Promise<boolean> {
|
const copiedIds = new Set(context.copiedPendingBindingIds || []);
|
const pending = [...copiedIds].map((id) => {
|
const binding = context.bindings.find((item) => item.id === id);
|
if (!binding || binding.status !== 'PENDING') throw new Error('复制绑定上下文不一致');
|
return binding;
|
});
|
if (!pending.length) return false;
|
if (!context.upgradeOperationCode) throw new Error('复制绑定缺少升版操作码');
|
const inheritedFormulaLockBindingIds = new Set(formulas.inheritedFormulaLockBindingIds ?? []);
|
const snapshots = bridge.snapshotControls(pending, controls, { inheritedFormulaLockBindingIds });
|
if (snapshots.length !== pending.length) throw new Error('升版复制控件快照不完整');
|
await client.confirmVersionCopy(apiContext(), {
|
upgradeOperationCode: context.upgradeOperationCode,
|
expectedVersions: Object.fromEntries(pending.map((item) => [item.id, item.version])),
|
controls: snapshots,
|
});
|
if (disposed) return true;
|
context.bindings = context.bindings.map((item) => (copiedIds.has(item.id) ? { ...item, status: 'ACTIVE' } : item));
|
return true;
|
}
|
|
async function initialize(): Promise<void> {
|
clearReadyTimeout();
|
setWorking('正在读取模板标注...', true);
|
try {
|
const locateTag = instanceContext?.locateControlTag;
|
if (locateTag) {
|
const controls = await bridge.listControls();
|
if (disposed) return;
|
await locateControl(controls, locateTag);
|
if (disposed) return;
|
store.setControls(controls);
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '目标控件已定位' });
|
return;
|
}
|
await prepareDocumentMutation();
|
if (disposed) return;
|
const controls = await bridge.listControls();
|
if (disposed) return;
|
const context = await client.fetchAnnotationContext(apiContext());
|
if (disposed) return;
|
let formulaContext = await client.fetchFormulaMappings(apiContext());
|
if (disposed) return;
|
const copiedBindingsConfirmed = await confirmCopiedBindings(context, formulaContext, controls);
|
if (disposed) return;
|
if (copiedBindingsConfirmed) formulaContext = await client.fetchFormulaMappings(apiContext());
|
if (disposed) return;
|
bindingState.value = [...context.bindings];
|
fieldState.value = toTemplateFieldOptions(context.fields);
|
checkboxGroupState.value = [...(context.checkboxGroups ?? [])];
|
repeatGroupState.value = [...(context.repeatGroups ?? [])];
|
applyStepConfiguration(context.stepConfiguration);
|
formulaBindingState.value = [...formulaContext.bindings];
|
formulaVersionState.value = [...formulaContext.versions];
|
const crossTemplateNeedsReconciliation = await reconcilePendingCrossTemplateBindings(bindingState.value, controls);
|
if (disposed) return;
|
await confirmCopiedFormulaBindings(formulaContext, bindingState.value);
|
if (disposed) return;
|
formulaBindingState.value = [...formulaContext.bindings];
|
const formulaNeedsReconciliation = await reconcilePendingFormulaBindings(formulaBindingState.value, bindingState.value);
|
if (disposed) return;
|
store.setControls(controls);
|
store.setStatus('ready');
|
if (!formulaNeedsReconciliation && !crossTemplateNeedsReconciliation) store.setOperation({ kind: 'success', message: '模板标注已加载' });
|
if (instanceContext?.repairBindingId) await prepareRepairMode(instanceContext.repairBindingId, controls);
|
} catch (error) {
|
if (!disposed) {
|
expireTicket(error);
|
store.setStatus('error');
|
store.setOperation({ kind: 'error', message: `读取模板标注失败：${message(error)}` });
|
}
|
throw error;
|
}
|
}
|
|
async function prepareRepairMode(bindingId: string, controls: Array<{ InternalId?: string; Tag?: string }>): Promise<void> {
|
const current = bindingState.value.find((item) => item.id === bindingId && item.status === 'ACTIVE');
|
if (!current) throw new Error('修复绑定不存在或状态已变化');
|
const matches = controls.filter((item) => item.Tag === current.controlTag);
|
if (matches.length > 1) throw new Error('修复目标 Tag 在文档中出现多次');
|
if (matches.length === 1) {
|
if (matches[0]?.InternalId) await bridge.selectControl(matches[0].InternalId, abortController.signal);
|
if (disposed) return;
|
pendingRepair.value = null;
|
store.setOperation({ kind: 'success', message: '目标控件已定位' });
|
return;
|
}
|
const check = await client.fetchRepairContext(apiContext(), bindingId);
|
if (disposed) return;
|
if (check.binding.id !== bindingId || check.binding.controlTag !== current.controlTag) throw new Error('修复上下文与目标绑定不一致');
|
pendingRepair.value = check;
|
store.setOperation({ kind: 'success', message: '请在文档中选择位置后恢复控件' });
|
}
|
|
async function refresh(): Promise<void> {
|
return exclusive(async () => {
|
setWorking('正在刷新模板标注...');
|
try {
|
const controls = await bridge.listControls();
|
if (disposed) return;
|
const locateTag = instanceContext?.locateControlTag;
|
if (locateTag) {
|
await locateControl(controls, locateTag);
|
if (disposed) return;
|
store.setControls(controls);
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '目标控件已定位' });
|
return;
|
}
|
const context = await client.fetchAnnotationContext(apiContext());
|
if (disposed) return;
|
const formulaContext = await client.fetchFormulaMappings(apiContext());
|
if (disposed) return;
|
bindingState.value = [...context.bindings];
|
fieldState.value = toTemplateFieldOptions(context.fields);
|
checkboxGroupState.value = [...(context.checkboxGroups ?? [])];
|
repeatGroupState.value = [...(context.repeatGroups ?? [])];
|
applyStepConfiguration(context.stepConfiguration);
|
formulaBindingState.value = [...formulaContext.bindings];
|
formulaVersionState.value = [...formulaContext.versions];
|
store.setControls(controls);
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '模板标注已刷新' });
|
} catch (error) {
|
if (!disposed) store.setOperation({ kind: 'error', message: `刷新失败：${message(error)}` });
|
throw error;
|
}
|
});
|
}
|
|
function loadCrossTemplateSourceTemplates(): Promise<void> {
|
return exclusive(async () => {
|
setWorking('正在读取来源模板...');
|
crossTemplateScalarCandidateState.value = [];
|
const templates = await client.fetchCrossTemplateSourceTemplates(apiContext());
|
if (disposed) return;
|
crossTemplateSourceTemplateState.value = Array.isArray(templates) ? templates : [];
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '来源模板已加载' });
|
});
|
}
|
|
function loadCrossTemplateScalarCandidates(sourceTemplateId: string): Promise<void> {
|
return exclusive(async () => {
|
setWorking('正在读取模板字段...');
|
crossTemplateScalarCandidateState.value = [];
|
const candidates = await client.fetchCrossTemplateScalarCandidates(apiContext(), sourceTemplateId);
|
if (disposed) return;
|
crossTemplateScalarCandidateState.value = Array.isArray(candidates) ? candidates : [];
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '模板字段已加载' });
|
});
|
}
|
|
async function insertReserved(reserve: () => Promise<TemplateBinding>, referencePrimaryTag?: string, readOnly = false): Promise<void> {
|
let reserved: TemplateBinding | undefined;
|
let insertedControl: { InternalId?: string; Lock?: string; Tag?: string } | undefined;
|
let readOnlyInsertAttempted = false;
|
let activationAttempted = false;
|
let confirmedControls: Array<{ InternalId?: string; Lock?: string; Tag?: string }> | undefined;
|
try {
|
reserved = await reserve();
|
if (disposed) return;
|
const before = await bridge.listControls();
|
if (disposed) return;
|
if (countTag(before, reserved.controlTag) !== 0) throw new Error('目标 Tag 已存在');
|
await prepareDocumentMutation();
|
if (disposed) return;
|
if (referencePrimaryTag) await bridge.insertReference(reserved, referencePrimaryTag, abortController.signal);
|
else if (readOnly) {
|
readOnlyInsertAttempted = true;
|
await bridge.insertReadOnlyBinding(reserved, abortController.signal);
|
}
|
else await bridge.insertBinding(reserved, abortController.signal);
|
// 销毁后不再补偿写 DOCX/API；PENDING 残留由重开对账与模板体检处理。
|
if (disposed) return;
|
const after = await bridge.listControls();
|
if (disposed) return;
|
if (countTag(after, reserved.controlTag) !== 1) throw new Error('插入后 Tag 计数不是 1');
|
if (readOnly) {
|
insertedControl = after.find((control) => control.Tag === reserved!.controlTag);
|
if (insertedControl?.Lock !== 'sdtContentLocked') throw new Error('跨模板字段控件未锁定');
|
}
|
confirmedControls = after;
|
activationAttempted = true;
|
await client.activateBinding(apiContext(), reserved.id, { operationCode: generateOpaqueId('activate') });
|
if (disposed) return;
|
bindingState.value = [...bindingState.value, { ...reserved, status: 'ACTIVE' }];
|
store.setControls(after);
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: `已标注字段：${reserved.controlAlias || reserved.fieldCode}` });
|
} catch (error) {
|
let rollbackError: unknown;
|
let preserveForReconciliation = false;
|
if (!disposed && readOnly && activationAttempted && reserved && !isExpiredTicket(error)) {
|
try {
|
const context = await client.fetchAnnotationContext(apiContext());
|
if (disposed) return;
|
const persisted = context.bindings.find((binding) => binding.id === reserved!.id);
|
if (persisted?.status === 'ACTIVE' && isCrossTemplateReadOnlyBinding(persisted)) {
|
bindingState.value = [...bindingState.value.filter((binding) => binding.id !== persisted.id), persisted];
|
store.setControls(confirmedControls ?? []);
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: `已标注字段：${persisted.controlAlias || persisted.fieldCode}` });
|
return;
|
}
|
if (!persisted || persisted.status !== 'PENDING') {
|
preserveForReconciliation = true;
|
rollbackError = new Error('跨模板字段激活结果待对账');
|
}
|
} catch (statusError) {
|
if (isExpiredTicket(statusError)) throw statusError;
|
preserveForReconciliation = true;
|
rollbackError = new Error('跨模板字段激活结果待对账');
|
}
|
}
|
if (!disposed && readOnlyInsertAttempted && !insertedControl && reserved && !isExpiredTicket(error)) {
|
try {
|
const controls = await bridge.listControls();
|
const matches = controls.filter((control) => control.Tag === reserved!.controlTag);
|
if (matches.length > 1 || (matches.length === 1 && !matches[0]?.InternalId)) {
|
throw new Error('跨模板失败控件无法唯一补偿');
|
}
|
insertedControl = matches[0];
|
} catch (enumerateError) {
|
rollbackError = enumerateError;
|
}
|
}
|
if (!disposed && insertedControl?.InternalId && !rollbackError && !isExpiredTicket(error)) {
|
try {
|
await bridge.deleteControl(insertedControl.InternalId);
|
} catch (deleteError) {
|
rollbackError = deleteError;
|
}
|
}
|
if (!disposed && reserved?.status === 'PENDING' && !rollbackError && !isExpiredTicket(error)) {
|
try {
|
await client.cancelBinding(apiContext(), reserved.id, { operationCode: generateOpaqueId('cancel'), reason: message(error) });
|
} catch {
|
/* 保留原始错误 */
|
}
|
}
|
if (!disposed) {
|
store.setStatus(contextStore.context ? 'ready' : 'error');
|
store.setOperation({
|
kind: 'error',
|
message: preserveForReconciliation
|
? message(rollbackError)
|
: rollbackError
|
? `标注失败，控件删除待对账：${message(rollbackError)}`
|
: `标注失败：${message(error)}`,
|
});
|
}
|
throw preserveForReconciliation ? rollbackError : error;
|
}
|
}
|
|
function insertSelectedField(field: TemplateFieldOption, checkboxGroup?: TemplateCheckboxGroupDraft): Promise<void> {
|
return exclusive(async () => {
|
if (bindingState.value.some((item) => item.status === 'ACTIVE' && item.controlRole === 'PRIMARY' && item.fieldId === field.fieldId))
|
throw new Error('该字段已有主控件，请插入引用');
|
const stepId = requireCurrentStepId();
|
setWorking('正在标注当前位置...');
|
await insertReserved(() =>
|
client.reservePrimaryBinding(apiContext(), {
|
checkboxGroupCode: field.type === 'CHECKBOX' ? checkboxGroup?.groupCode.trim() || undefined : undefined,
|
checkboxGroupMaxSelected: field.type === 'CHECKBOX' ? checkboxGroup?.maxSelected : undefined,
|
checkboxGroupMinSelected: field.type === 'CHECKBOX' ? checkboxGroup?.minSelected : undefined,
|
fieldId: field.fieldId,
|
fieldVersionId: field.fieldVersionId,
|
operationCode: generateOpaqueId('reserve'),
|
repeatRequest: false,
|
stepId,
|
}),
|
);
|
});
|
}
|
|
function suggestCode(text: string): Promise<string> {
|
return client.suggestCode(apiContext(), { text });
|
}
|
|
function insertRepeatField(field: TemplateFieldOption, group: TemplateRepeatGroup, checkboxGroup?: TemplateCheckboxGroupDraft): Promise<void> {
|
return exclusive(async () => {
|
const normalizedGroup = group.groupCode.trim();
|
const { maxRows, minRows } = group;
|
if (!/^[\w-]{1,80}$/u.test(normalizedGroup)) throw new Error('重复组编码无效');
|
if (!Number.isInteger(minRows) || !Number.isInteger(maxRows) || minRows < 0 || maxRows < minRows || maxRows > 1000) throw new Error('重复组行数约束无效');
|
const existingGroup = repeatGroupState.value.find((item) => item.groupCode === normalizedGroup);
|
if (existingGroup && (!existingGroup.stepId || !stepConfigurationState.value?.steps.some((step) => step.id === existingGroup.stepId))) {
|
throw new Error('重复组步骤归属无效');
|
}
|
const stepId = existingGroup?.stepId ?? requireCurrentStepId();
|
setWorking('正在标注重复行...');
|
await insertReserved(() =>
|
client.reservePrimaryBinding(apiContext(), {
|
checkboxGroupCode: field.type === 'CHECKBOX' ? checkboxGroup?.groupCode.trim() || undefined : undefined,
|
checkboxGroupMaxSelected: field.type === 'CHECKBOX' ? checkboxGroup?.maxSelected : undefined,
|
checkboxGroupMinSelected: field.type === 'CHECKBOX' ? checkboxGroup?.minSelected : undefined,
|
fieldId: field.fieldId,
|
fieldVersionId: field.fieldVersionId,
|
maxRows,
|
minRows,
|
operationCode: generateOpaqueId('repeat-reserve'),
|
repeatGroupCode: normalizedGroup,
|
repeatPrototypeRowId: 'prototype',
|
repeatRequest: true,
|
stepId,
|
}),
|
);
|
if (!disposed && !repeatGroupState.value.some((item) => item.groupCode === normalizedGroup)) {
|
repeatGroupState.value = [...repeatGroupState.value, { groupCode: normalizedGroup, minRows, maxRows, stepId }].sort((left, right) =>
|
left.groupCode.localeCompare(right.groupCode),
|
);
|
}
|
});
|
}
|
|
function changeCheckboxGroup(bindingId: string, checkboxGroup: null | TemplateCheckboxGroupDraft, expectedVersion: number): Promise<void> {
|
return exclusive(async () => {
|
setWorking('正在更新选择组...');
|
const updated = await client.changeCheckboxGroup(apiContext(), bindingId, {
|
checkboxGroupCode: checkboxGroup?.groupCode.trim() || null,
|
checkboxGroupMaxSelected: checkboxGroup?.maxSelected,
|
checkboxGroupMinSelected: checkboxGroup?.minSelected,
|
expectedVersion,
|
operationCode: generateOpaqueId('checkbox-group'),
|
});
|
if (disposed) return;
|
bindingState.value = bindingState.value.map((binding) => (binding.id === updated.id ? updated : binding));
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: updated.checkboxGroupCode ? `已加入选择组：${updated.checkboxGroupCode}` : '已移出选择组' });
|
});
|
}
|
|
function changeCheckboxGroupRule(
|
groupCode: string,
|
minSelected: number,
|
maxSelected: null | number,
|
expectedVersion: number,
|
): Promise<void> {
|
return exclusive(async () => {
|
setWorking('正在更新选择组规则...');
|
const updated = await client.changeCheckboxGroupRule(apiContext(), groupCode, {
|
expectedVersion,
|
maxSelected,
|
minSelected,
|
operationCode: generateOpaqueId('checkbox-group-rule'),
|
});
|
if (disposed) return;
|
checkboxGroupState.value = checkboxGroupState.value.map((group) => (group.groupCode === updated.groupCode ? updated : group));
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: `已更新选择组规则：${updated.groupCode}` });
|
});
|
}
|
|
function insertCrossTemplateScalar(candidate: CrossTemplateScalarCandidate): Promise<void> {
|
return exclusive(async () => {
|
const stepId = requireCurrentStepId();
|
setWorking('正在标注跨模板字段值...');
|
await insertReserved(
|
() =>
|
client.reserveCrossTemplateScalarBinding(apiContext(), {
|
operationCode: generateOpaqueId('cross-template-reserve'),
|
repeatRequest: false,
|
sourceFieldId: candidate.sourceFieldId,
|
sourceFieldVersionId: candidate.sourceFieldVersionId,
|
sourceTemplateCode: candidate.sourceTemplateCode,
|
sourceTemplateId: candidate.sourceTemplateId,
|
stepId,
|
}),
|
undefined,
|
true,
|
);
|
});
|
}
|
|
function createPrivateField(draft: TemplatePrivateFieldDraft): Promise<void> {
|
return exclusive(async () => {
|
const stepId = requireCurrentStepId();
|
setWorking('正在创建本模板字段...');
|
await insertReserved(() => client.reservePrivateField(apiContext(), { ...draft, operationCode: generateOpaqueId('private'), stepId }));
|
if (disposed) return;
|
const context = await client.fetchAnnotationContext(apiContext());
|
if (disposed) return;
|
bindingState.value = [...context.bindings];
|
fieldState.value = toTemplateFieldOptions(context.fields);
|
checkboxGroupState.value = [...(context.checkboxGroups ?? [])];
|
repeatGroupState.value = [...(context.repeatGroups ?? [])];
|
applyStepConfiguration(context.stepConfiguration);
|
});
|
}
|
|
function insertReference(primaryBindingId: string): Promise<void> {
|
return exclusive(async () => {
|
const primary = bindingState.value.find((item) => item.id === primaryBindingId && item.status === 'ACTIVE' && item.controlRole === 'PRIMARY');
|
if (!primary) throw new Error('主字段绑定不存在或状态已变化');
|
setWorking('正在插入字段引用...');
|
await insertReserved(
|
() => client.reserveReferenceBinding(apiContext(), primary.id, { operationCode: generateOpaqueId('reference') }),
|
primary.controlTag,
|
);
|
});
|
}
|
|
function reserveFormulaBinding(request: Omit<FormulaBindingRequest, 'operationCode'>): Promise<void> {
|
return exclusive(async () => {
|
const resultBinding = formulaResultBinding({ ...request, id: '', operationCode: '', status: 'PENDING', version: 0 });
|
setWorking('正在锁定公式结果字段...');
|
let reserved: TemplateFormulaBinding | undefined;
|
let lockSnapshot: FormulaResultLockSnapshot | undefined;
|
try {
|
await prepareDocumentMutation();
|
if (disposed) return;
|
lockSnapshot = await bridge.lockFormulaResult(resultBinding.controlTag);
|
if (disposed) return;
|
reserved = await client.reserveFormulaBinding(apiContext(), {
|
...buildFormulaBindingRequest({ ...request, operationCode: generateOpaqueId('formula-reserve') }),
|
jieguoSuoKuaizhao: formulaOriginalLockControls(request.resultBindingId, lockSnapshot),
|
});
|
if (disposed) return;
|
await client.activateFormulaBinding(apiContext(), reserved.id, {
|
controls: formulaResultControls(reserved.resultBindingId, 'sdtContentLocked'),
|
expectedVersion: reserved.version,
|
operationCode: reserved.operationCode,
|
});
|
if (disposed) return;
|
formulaBindingState.value = [...formulaBindingState.value, { ...reserved, status: 'ACTIVE' }];
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '公式映射已启用' });
|
} catch (error) {
|
let recoveryError: unknown;
|
if (!disposed && lockSnapshot && !isExpiredTicket(error)) {
|
try {
|
await bridge.restoreFormulaResultLocks(lockSnapshot);
|
} catch (restoreError) {
|
recoveryError = restoreError;
|
}
|
}
|
if (!disposed && reserved?.status === 'PENDING' && !recoveryError && !isExpiredTicket(error)) {
|
try {
|
await client.cancelFormulaBinding(apiContext(), reserved.id, {
|
expectedVersion: reserved.version,
|
operationCode: reserved.operationCode,
|
reason: message(error),
|
});
|
} catch {
|
/* 保留原始失败 */
|
}
|
}
|
if (!disposed) {
|
store.setStatus(contextStore.context ? 'ready' : 'error');
|
store.setOperation({
|
kind: 'error',
|
message: recoveryError ? `公式映射失败，结果锁需对账：${message(recoveryError)}` : `公式映射失败：${message(error)}`,
|
});
|
}
|
throw error;
|
}
|
});
|
}
|
|
function repairBindingId(bindingId: string): Promise<void> {
|
return exclusive(async () => {
|
const current = bindingState.value.find((item) => item.id === bindingId);
|
if (!current) throw new Error('修复绑定不存在');
|
setWorking('正在恢复控件...');
|
const before = await bridge.listControls();
|
if (disposed) return;
|
const matches = before.filter((item) => item.Tag === current.controlTag);
|
if (matches.length > 1) throw new Error('修复目标 Tag 在文档中出现多次');
|
if (matches.length === 1) {
|
if (!matches[0]?.InternalId) throw new Error('修复目标控件缺少 InternalId');
|
const retry = pendingRepairConfirmation?.binding.id === bindingId ? pendingRepairConfirmation : null;
|
if (retry) {
|
try {
|
await client.confirmRepair(apiContext(), bindingId, confirmation(retry, before));
|
pendingRepairConfirmation = null;
|
} catch (error) {
|
if (!(error instanceof TypeError)) pendingRepairConfirmation = null;
|
throw error;
|
}
|
if (disposed) return;
|
}
|
await bridge.selectControl(matches[0].InternalId, abortController.signal);
|
if (disposed) return;
|
if (!disposed) {
|
pendingRepair.value = null;
|
store.setControls(before);
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: retry ? '控件已恢复' : '目标控件已定位' });
|
}
|
return;
|
}
|
let check = pendingRepair.value?.binding.id === bindingId ? pendingRepair.value : null;
|
if (!check) {
|
check = await client.fetchRepairContext(apiContext(), bindingId);
|
if (disposed) return;
|
}
|
await prepareDocumentMutation();
|
if (disposed) return;
|
await bridge.insertBinding(check.binding, abortController.signal);
|
if (disposed) return;
|
const after = await bridge.listControls();
|
if (disposed) return;
|
if (countTag(after, check.binding.controlTag) !== 1) throw new Error('修复后 Tag 计数不是 1');
|
pendingRepairConfirmation = check;
|
try {
|
await client.confirmRepair(apiContext(), bindingId, confirmation(check, after));
|
pendingRepairConfirmation = null;
|
} catch (error) {
|
if (!(error instanceof TypeError)) pendingRepairConfirmation = null;
|
throw error;
|
}
|
if (disposed) return;
|
if (!disposed) {
|
pendingRepair.value = null;
|
store.setControls(after);
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '控件已恢复' });
|
}
|
});
|
}
|
|
function removeFormulaBinding(bindingId: string): Promise<void> {
|
return exclusive(async () => {
|
const current = formulaBindingState.value.find((item) => item.id === bindingId && item.status === 'ACTIVE');
|
if (!current) throw new Error('公式映射不存在或状态已变化');
|
const resultBinding = formulaResultBinding(current);
|
setWorking('正在解除公式结果锁...');
|
const check = await client.checkFormulaBindingRemoval(apiContext(), bindingId);
|
if (check.downstreamFormulaBindingIds.length > 0) {
|
throw new Error('公式结果仍被下游公式引用');
|
}
|
await prepareDocumentMutation();
|
if (disposed) return;
|
const lockedSnapshot = await bridge.lockFormulaResult(resultBinding.controlTag);
|
try {
|
await bridge.unlockFormulaResult(resultBinding.controlTag);
|
await client.confirmFormulaBindingRemoval(apiContext(), bindingId, {
|
controls: formulaResultControls(current.resultBindingId, ''),
|
expectedVersion: expectedFormulaVersion(check.expectedVersions, bindingId),
|
operationCode: check.operationCode,
|
});
|
formulaBindingState.value = formulaBindingState.value.map((item) => (item.id === bindingId ? { ...item, status: 'REMOVED' } : item));
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '公式映射已移除' });
|
} catch (error) {
|
if (!isExpiredTicket(error))
|
try {
|
await bridge.restoreFormulaResultLocks(lockedSnapshot);
|
} catch (restoreError) {
|
store.setOperation({ kind: 'error', message: `公式结果锁恢复失败，模板发布将被阻止：${message(restoreError)}` });
|
}
|
throw error;
|
}
|
});
|
}
|
|
function upgradeFormulaBinding(bindingId: string, request: Omit<FormulaBindingRequest, 'operationCode'>): Promise<void> {
|
return exclusive(async () => {
|
const current = formulaBindingState.value.find((item) => item.id === bindingId && item.status === 'ACTIVE');
|
if (!current) throw new Error('公式映射不存在或状态已变化');
|
setWorking('正在升级公式映射...');
|
const check = await client.checkFormulaBindingUpgrade(
|
apiContext(),
|
bindingId,
|
buildFormulaBindingRequest({ ...request, operationCode: generateOpaqueId('formula-upgrade') }),
|
);
|
const targetResult = formulaResultBinding({ ...request, id: bindingId, operationCode: '', status: 'ACTIVE', version: current.version });
|
const currentResult = formulaResultBinding(current);
|
await prepareDocumentMutation();
|
if (disposed) return;
|
const snapshots = [await bridge.lockFormulaResult(targetResult.controlTag)];
|
if (targetResult.controlTag !== currentResult.controlTag) {
|
try {
|
const oldLocked = await bridge.lockFormulaResult(currentResult.controlTag);
|
snapshots.push(oldLocked);
|
await bridge.unlockFormulaResult(currentResult.controlTag);
|
} catch (error) {
|
if (!isExpiredTicket(error)) await bridge.restoreFormulaResultLocks(snapshots[0]!);
|
throw error;
|
}
|
}
|
try {
|
const confirm = {
|
controls: formulaResultControls(request.resultBindingId, 'sdtContentLocked'),
|
expectedVersion: expectedFormulaVersion(check.expectedVersions, bindingId),
|
operationCode: check.operationCode,
|
target: buildFormulaBindingRequest({ ...request, operationCode: check.operationCode }),
|
};
|
try {
|
await client.confirmFormulaBindingUpgrade(apiContext(), bindingId, confirm);
|
} catch (error) {
|
if (!(error instanceof TypeError)) throw error;
|
try {
|
await client.confirmFormulaBindingUpgrade(apiContext(), bindingId, confirm);
|
} catch (retryError) {
|
if (retryError instanceof TypeError) throw new FormulaConfirmAmbiguousError();
|
throw retryError;
|
}
|
}
|
formulaBindingState.value = formulaBindingState.value.map((item) =>
|
item.id === bindingId ? { ...item, ...request, operationCode: check.operationCode, status: 'ACTIVE' } : item,
|
);
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '公式映射已升级' });
|
} catch (error) {
|
if (!isExpiredTicket(error) && !(error instanceof FormulaConfirmAmbiguousError))
|
for (const snapshot of snapshots) {
|
try {
|
await bridge.restoreFormulaResultLocks(snapshot);
|
} catch {
|
/* 保留后端失败并要求后续对账 */
|
}
|
}
|
if (!disposed && error instanceof FormulaConfirmAmbiguousError) {
|
store.setStatus('ready');
|
store.setOperation({ kind: 'error', message: `公式升级待对账：${message(error)}` });
|
}
|
throw error;
|
}
|
});
|
}
|
|
async function executeCheckedChange(
|
operationKey: string,
|
bindingId: string,
|
operationLabel: string,
|
check: () => Promise<TemplateChangeCheck>,
|
confirm: (form: ReturnType<typeof confirmation>) => Promise<void>,
|
): Promise<void> {
|
try {
|
const result = pendingCheckedChanges.get(operationKey) ?? (await check());
|
if (disposed) return;
|
await prepareDocumentMutation();
|
if (disposed) return;
|
await bridge.applyControlPlan(bindingState.value, result.controls, abortController.signal);
|
if (disposed) return;
|
const controls = await bridge.listControls();
|
if (disposed) return;
|
const form = confirmation(result, controls);
|
try {
|
await confirm(form);
|
pendingCheckedChanges.delete(operationKey);
|
} catch (error) {
|
if (!disposed && error instanceof TypeError) pendingCheckedChanges.set(operationKey, result);
|
else pendingCheckedChanges.delete(operationKey);
|
throw error;
|
}
|
if (disposed) return;
|
const desiredIds = new Set(result.controls.map((item) => item.bindingId));
|
const affectedIds = new Set([bindingId, ...Object.keys(result.expectedVersions)]);
|
bindingState.value = bindingState.value.map((item) =>
|
desiredIds.has(item.id)
|
? bindingsForSnapshots(result.controls).find((value) => value.id === item.id)!
|
: affectedIds.has(item.id) && item.status === 'ACTIVE'
|
? { ...item, status: 'REMOVED' }
|
: item,
|
);
|
store.setControls(controls);
|
} catch (error) {
|
if (!disposed) store.setOperation({ kind: 'error', message: `${operationLabel}失败：${message(error)}` });
|
throw error;
|
}
|
}
|
|
function removeBinding(bindingId: string): Promise<void> {
|
return exclusive(async () =>
|
executeCheckedChange(
|
`remove:${bindingId}`,
|
bindingId,
|
'删除',
|
() => client.checkBindingRemoval(apiContext(), bindingId),
|
(form) => client.confirmBindingRemoval(apiContext(), bindingId, form),
|
),
|
);
|
}
|
|
function removeOrphanControl(internalId: string): Promise<void> {
|
return exclusive(async () => {
|
setWorking('正在删除异常控件...');
|
await prepareDocumentMutation();
|
if (disposed) return;
|
const controls = await bridge.deleteControl(internalId);
|
if (disposed) return;
|
store.setControls(controls);
|
store.setStatus('ready');
|
store.setOperation({ kind: 'success', message: '异常控件已删除' });
|
});
|
}
|
|
function promoteReference(bindingId: string): Promise<void> {
|
return exclusive(async () =>
|
executeCheckedChange(
|
`promote:${bindingId}`,
|
bindingId,
|
'设为主字段',
|
() => client.checkReferencePromotion(apiContext(), bindingId),
|
(form) => client.confirmReferencePromotion(apiContext(), bindingId, form),
|
),
|
);
|
}
|
|
function upgradeBinding(bindingId: string, targetFieldVersionId: string): Promise<void> {
|
return exclusive(async () =>
|
executeCheckedChange(
|
`upgrade:${bindingId}:${targetFieldVersionId}`,
|
bindingId,
|
'字段升级',
|
() => client.checkBindingVersionUpgrade(apiContext(), bindingId, { targetFieldVersionId }),
|
(form) => client.confirmBindingVersionUpgrade(apiContext(), bindingId, { ...form, targetFieldVersionId }),
|
),
|
);
|
}
|
|
function select(internalId: string): Promise<void> {
|
return exclusive(() => bridge.selectControl(internalId, abortController.signal));
|
}
|
|
const cleanup = bridge.bindLifecycle({
|
onReady: () => {
|
if (disposed || !contextStore.initialize(bridge.getRuntimeOptions())) {
|
if (!disposed) {
|
store.setStatus('error');
|
store.setOperation({ kind: 'error', message: contextStore.error });
|
}
|
return;
|
}
|
instanceContext = contextStore.context;
|
void initialize().catch(() => undefined);
|
},
|
onThemeChanged: () => undefined,
|
});
|
readyTimeout = setTimeout(() => {
|
readyTimeout = undefined;
|
if (!disposed && store.status === 'initializing') {
|
store.setStatus('error');
|
store.setOperation({ kind: 'error', message: 'ONLYOFFICE SDK 初始化超时' });
|
}
|
}, SDK_READY_TIMEOUT_MS);
|
|
function dispose(): void {
|
if (disposed) return;
|
disposed = true;
|
clearReadyTimeout();
|
abortController.abort();
|
cleanup();
|
bindingState.value = [];
|
fieldState.value = [];
|
checkboxGroupState.value = [];
|
crossTemplateScalarCandidateState.value = [];
|
crossTemplateSourceTemplateState.value = [];
|
repeatGroupState.value = [];
|
stepConfigurationState.value = null;
|
currentStepIdState.value = null;
|
formulaBindingState.value = [];
|
formulaVersionState.value = [];
|
pendingRepair.value = null;
|
pendingRepairConfirmation = null;
|
pendingCheckedChanges.clear();
|
instanceContext = null;
|
contextStore.reset();
|
}
|
|
return {
|
contextStore,
|
store,
|
initialize,
|
refresh,
|
loadCrossTemplateSourceTemplates,
|
loadCrossTemplateScalarCandidates,
|
suggestCode,
|
insertSelectedField,
|
insertRepeatField,
|
changeCheckboxGroup,
|
changeCheckboxGroupRule,
|
insertCrossTemplateScalar,
|
createPrivateField,
|
insertReference,
|
repairBindingId,
|
removeBinding,
|
removeOrphanControl,
|
removeFormulaBinding,
|
promoteReference,
|
reserveFormulaBinding,
|
upgradeBinding,
|
upgradeFormulaBinding,
|
select,
|
setCurrentStepId,
|
dispose,
|
get bindings() {
|
return bindingState.value;
|
},
|
get fields() {
|
return fieldState.value;
|
},
|
get checkboxGroups() {
|
return checkboxGroupState.value;
|
},
|
get crossTemplateScalarCandidates() {
|
return crossTemplateScalarCandidateState.value;
|
},
|
get crossTemplateSourceTemplates() {
|
return crossTemplateSourceTemplateState.value;
|
},
|
get repeatGroups() {
|
return repeatGroupState.value;
|
},
|
get stepConfiguration() {
|
return stepConfigurationState.value;
|
},
|
get currentStepId() {
|
return currentStepIdState.value;
|
},
|
get formulaBindings() {
|
return formulaBindingState.value;
|
},
|
get formulaVersions() {
|
return formulaVersionState.value;
|
},
|
get pendingRepairBindingId() {
|
return pendingRepair.value?.binding.id ?? null;
|
},
|
get repairMode() {
|
return Boolean(instanceContext?.repairBindingId);
|
},
|
};
|
}
|
