import type { FieldChange, FillDataResponse, FillFieldValue, RepeatRow, SourceSyncPreview, StepFillStructure, StepProgress } from '../domain/types';
|
import type { EditorControlEvent, OnlyOfficeBridge } from '../onlyoffice/bridge';
|
|
import { computed, ref } from 'vue';
|
|
import {
|
appendRepeatRow as requestRepeatRow,
|
deleteRepeatRow as requestDeleteRepeatRow,
|
fetchFillData,
|
previewSourceSync as requestSourceSyncPreview,
|
restoreRepeatRow as requestRestoreRepeatRow,
|
synchronizeSource as requestSourceSync,
|
} from '../api/record-fill';
|
import { checkboxGroupRuntimeIdentity } from '../domain/checkbox-group';
|
import { buildDraftFields } from '../domain/draft';
|
import { parsePluginContext, RECORD_FILL_BIZ_SCENE } from '../domain/plugin-context';
|
import { parseTag, primaryFieldTag } from '../domain/tags';
|
import { useFillerStore } from '../stores/record-filler';
|
|
const SDK_READY_TIMEOUT_MS = 5_000;
|
const DOCUMENT_CHANGE_DEBOUNCE_MS = 150;
|
function assignedStepId(tag: string, structure: StepFillStructure): string | undefined {
|
const parsed = parseTag(tag);
|
if (parsed?.type === 'repeat') return structure.repeatGroupSteps[parsed.groupCode];
|
const controlTag = primaryFieldTag(tag);
|
return controlTag ? structure.controlSteps[controlTag] : undefined;
|
}
|
|
export function useRecordFiller(bridge: OnlyOfficeBridge) {
|
const store = useFillerStore();
|
const recordHostContext = ref<null | { bizDataId: string; documentId: string }>(null);
|
const isMultiStep = computed(() => Boolean(store.stepStructure && !store.stepStructure.configuration.singleStep));
|
const currentStepId = computed(() => store.currentStepId);
|
const conflictCount = computed(() => Object.keys(store.conflicts).length);
|
const sourceSyncPreview = ref<null | SourceSyncPreview>(null);
|
const sourceSyncLoading = ref(false);
|
const visibleFields = computed(() => {
|
if (!isMultiStep.value) return store.fields;
|
const structure = store.stepStructure;
|
if (!structure || !store.currentStepId) return [];
|
return store.fields.filter((field) => assignedStepId(field.tag, structure) === store.currentStepId);
|
});
|
const visibleRepeatGroups = computed(() => {
|
if (!isMultiStep.value) return store.repeatGroups;
|
const structure = store.stepStructure;
|
if (!structure || !store.currentStepId) return [];
|
return store.repeatGroups.filter((group) => structure.repeatGroupSteps[group.groupCode] === store.currentStepId);
|
});
|
const stepProgress = computed<StepProgress[]>(() => {
|
const structure = store.stepStructure;
|
if (!structure) return [];
|
return [...structure.configuration.steps]
|
.sort((left, right) => left.order - right.order)
|
.map((step) => {
|
const belongsToStep = (tag: string) => {
|
return assignedStepId(tag, structure) === step.id;
|
};
|
const stepFields = store.fields.filter((field) => {
|
const tag = parseTag(field.tag);
|
if (tag?.type === 'repeat') {
|
return tag.rowId !== 'prototype' && structure.repeatGroupSteps[tag.groupCode] === step.id;
|
}
|
return belongsToStep(field.tag);
|
});
|
const missingFields = stepFields.filter((field) => {
|
if (/^eln\.ref\./u.test(field.tag)) return false;
|
const empty = field.type === 'checkbox' ? field.draftValue !== true : String(field.draftValue).trim() === '';
|
return (
|
field.requiredKnown === false ||
|
(Boolean(field.required) && empty) ||
|
field.formulaStatus === 'MISSING_INPUT' ||
|
(store.formulaResultsStale && Boolean(field.formulaStatus))
|
);
|
}).length;
|
const missingGroups = store.repeatGroups.filter(
|
(group) =>
|
structure.repeatGroupSteps[group.groupCode] === step.id && group.rows.filter((row) => row.status !== 'DELETE_PREPARED').length < group.minRows,
|
).length;
|
const problemTags = new Set([...Object.keys(store.fieldErrors), ...Object.keys(store.conflicts)].filter(belongsToStep));
|
const formulaErrorCount = stepFields.filter(
|
(field) => !store.formulaResultsStale && !problemTags.has(field.tag) && field.formulaStatus === 'ERROR',
|
).length;
|
const problemCount = problemTags.size + formulaErrorCount;
|
const missingCount = missingFields + missingGroups;
|
return {
|
missingCount,
|
problemCount,
|
status: problemCount ? 'problem' : missingCount ? 'in-progress' : 'complete',
|
step,
|
};
|
});
|
});
|
let context: null | ReturnType<typeof parsePluginContext> = null;
|
let initialized = false;
|
let fillData: FillDataResponse = { fields: {}, repeatGroups: [] };
|
const pendingRepeatOperations = new Map<string, string>();
|
const pendingDeleteOperations = new Map<string, string>();
|
const pendingDeletedValues = new Map<string, FieldChange[]>();
|
let sourceSyncOperationCode = '';
|
const changedControls = new Map<string, string>();
|
let documentChangeTimer: null | ReturnType<typeof setTimeout> = null;
|
let documentWriteDepth = 0;
|
function invalidateUnauthorizedContext(error: unknown): boolean {
|
const status = typeof error === 'object' && error !== null && 'status' in error ? (error as { status?: unknown }).status : undefined;
|
if (status !== 401 && status !== 403) return false;
|
context = null;
|
recordHostContext.value = null;
|
sourceSyncPreview.value = null;
|
sourceSyncOperationCode = '';
|
store.status = 'error';
|
store.message = error instanceof Error ? error.message : '填写凭证无效，请重新打开文档';
|
return true;
|
}
|
const readyTimeout = setTimeout(() => {
|
if (!initialized) {
|
store.status = 'error';
|
store.message = 'ONLYOFFICE SDK 初始化超时';
|
}
|
}, SDK_READY_TIMEOUT_MS);
|
function pendingChanges(confirmedFieldCodes: string[] = []): FieldChange[] {
|
return store.fields
|
.filter((field) => {
|
const parsed = parseTag(field.tag);
|
return field.draftValue !== field.documentValue
|
|| (parsed && parsed.type !== 'repeat' && confirmedFieldCodes.includes(parsed.fieldCode));
|
})
|
.map((field) => ({ tag: field.tag, type: field.type, value: field.draftValue }));
|
}
|
function fieldForControlEvent(control: EditorControlEvent) {
|
const tag = typeof control.Tag === 'string' ? control.Tag : '';
|
const internalId = typeof control.InternalId === 'string' ? control.InternalId : '';
|
if (!tag || !internalId) return undefined;
|
return store.fields.find((field) => field.tag === tag && field.internalId === internalId);
|
}
|
function selectFieldStep(tag: string) {
|
const structure = store.stepStructure;
|
if (!structure) return;
|
const stepId = assignedStepId(tag, structure);
|
if (stepId) store.selectStep(stepId);
|
}
|
async function flushDocumentChanges() {
|
documentChangeTimer = null;
|
if (documentWriteDepth) {
|
scheduleDocumentChanges();
|
return;
|
}
|
const expected = new Map(changedControls);
|
changedControls.clear();
|
try {
|
const fields = await bridge.inspectFields();
|
const selectedTargets = new Map<string, string[]>();
|
for (const [tag, internalId] of expected) {
|
const next = fields.find((field) => field.tag === tag && field.internalId === internalId);
|
const current = store.fields.find((field) => field.tag === tag && field.internalId === internalId);
|
if (!next || !current || next.type !== current.type) continue;
|
if (current.type === 'checkbox' && current.documentValue === false && next.currentValue === true) {
|
const identity = checkboxGroupRuntimeIdentity(current, store.stepStructure);
|
if (identity) selectedTargets.set(identity, [...(selectedTargets.get(identity) ?? []), tag]);
|
}
|
store.syncDocumentField(tag, next.currentValue);
|
}
|
const correctedTags = new Set<string>();
|
for (const [identity, targetTags] of selectedTargets) {
|
if (targetTags.length !== 1) continue;
|
const target = store.fields.find((field) => field.tag === targetTags[0]);
|
if (!target) continue;
|
const accepted = store.setDraft(target.tag, true);
|
if (!accepted) {
|
const notice = store.checkboxGroupNotice;
|
store.setDraft(target.tag, false);
|
store.checkboxGroupNotice = notice;
|
}
|
for (const candidate of store.fields) {
|
if (checkboxGroupRuntimeIdentity(candidate, store.stepStructure) !== identity) continue;
|
if (candidate.draftValue !== candidate.documentValue) correctedTags.add(candidate.tag);
|
}
|
}
|
const changes = [...correctedTags]
|
.flatMap((tag) => {
|
const field = store.fields.find((item) => item.tag === tag);
|
return field && field.draftValue !== field.documentValue
|
? [{ tag: field.tag, type: field.type, value: field.draftValue }]
|
: [];
|
});
|
if (changes.length) {
|
const results = await applyDocumentFields(changes);
|
store.applyResults(results, { preserveExistingErrors: true });
|
if (!results.every((result) => result.ok)) {
|
const verifiedFields = await bridge.inspectFields();
|
for (const change of changes) {
|
const verified = verifiedFields.find((field) => field.tag === change.tag);
|
const current = store.fields.find((field) => field.tag === change.tag);
|
if (verified && current && verified.type === current.type) {
|
store.syncDocumentField(change.tag, verified.currentValue);
|
}
|
}
|
}
|
}
|
store.documentSyncError = '';
|
} catch (error) {
|
store.documentSyncError = error instanceof Error ? error.message : String(error);
|
} finally {
|
if (changedControls.size) scheduleDocumentChanges();
|
}
|
}
|
function scheduleDocumentChanges() {
|
if (documentChangeTimer) clearTimeout(documentChangeTimer);
|
documentChangeTimer = setTimeout(() => void flushDocumentChanges(), DOCUMENT_CHANGE_DEBOUNCE_MS);
|
}
|
function onControlChanged(control: EditorControlEvent) {
|
const field = fieldForControlEvent(control);
|
if (!field) return;
|
changedControls.set(field.tag, field.internalId);
|
scheduleDocumentChanges();
|
}
|
function onControlFocused(control: EditorControlEvent) {
|
const field = fieldForControlEvent(control);
|
if (!field) return;
|
store.focusedTag = field.tag;
|
selectFieldStep(field.tag);
|
}
|
async function applyDocumentFields(changes: FieldChange[]) {
|
documentWriteDepth += 1;
|
try {
|
return await bridge.applyFields(changes);
|
} catch (error) {
|
const message = error instanceof Error ? error.message : String(error);
|
store.fieldErrors = Object.fromEntries(changes.map((change) => [change.tag, message]));
|
throw error;
|
} finally {
|
documentWriteDepth -= 1;
|
if (!documentWriteDepth && changedControls.size) scheduleDocumentChanges();
|
}
|
}
|
const pendingCount = computed(() => pendingChanges().length);
|
const canSynchronizeSource = computed(() => {
|
const initializedStatus = store.status;
|
return Boolean(initializedStatus !== 'initializing' && context?.canFill && context.bizScene === RECORD_FILL_BIZ_SCENE);
|
});
|
const recordHostState = computed(() => {
|
if (!recordHostContext.value) return null;
|
return {
|
bizDataId: recordHostContext.value.bizDataId,
|
documentId: recordHostContext.value.documentId,
|
pendingCount: pendingCount.value,
|
type: 'jnpf:eln-record-fill-state' as const,
|
version: 1 as const,
|
};
|
});
|
async function initialize() {
|
initialized = true;
|
clearTimeout(readyTimeout);
|
try {
|
context = parsePluginContext(bridge.getRuntimeOptions());
|
recordHostContext.value = context.bizScene === RECORD_FILL_BIZ_SCENE ? { bizDataId: context.bizDataId, documentId: context.documentId } : null;
|
if (context.bizScene === RECORD_FILL_BIZ_SCENE && context.canFill) {
|
await bridge.setFillOnlyMode(true);
|
}
|
const [data, fields] = await Promise.all([fetchFillData(context), bridge.inspectFields()]);
|
const pendingSync = data.pendingSourceSync;
|
fillData = data;
|
store.repeatGroups = data.repeatGroups;
|
store.setStepStructure(data.stepStructure);
|
for (const group of data.repeatGroups) {
|
for (const row of group.rows) {
|
if (row.deleteOperationCode) pendingDeleteOperations.set(repeatRowKey(group.groupCode, row.rowId), row.deleteOperationCode);
|
}
|
}
|
store.fields = buildDraftFields(fields, data, { ignoreDataValues: true });
|
store.refreshCheckboxGroupError();
|
if (!store.checkboxGroupError) {
|
store.fields = buildDraftFields(fields, data, { preferData: context.bizScene === RECORD_FILL_BIZ_SCENE });
|
store.refreshCheckboxGroupError();
|
}
|
if (context.bizScene === RECORD_FILL_BIZ_SCENE && context.canFill && !store.checkboxGroupError) {
|
const changes = pendingChanges(pendingSync?.changedFieldCodes);
|
if (changes.length) {
|
const results = await applyDocumentFields(changes);
|
store.applyResults(results);
|
if (!results.every((item) => item.ok)) {
|
store.status = 'error';
|
store.message = '数据库当前态恢复到文档失败';
|
return;
|
}
|
}
|
}
|
store.status = 'ready';
|
store.message = pendingSync && context.canFill
|
? '来源同步已恢复，等待文档保存确认'
|
: context.canFill ? '已连接' : '当前记录仅可查看';
|
} catch (error) {
|
if (!invalidateUnauthorizedContext(error)) {
|
store.status = 'error';
|
store.message = error instanceof Error ? error.message : String(error);
|
}
|
}
|
}
|
async function apply() {
|
if (!context?.canFill) return;
|
if (conflictCount.value || store.checkboxGroupError) return;
|
const changes = pendingChanges();
|
if (!changes.length) return;
|
store.status = 'working';
|
try {
|
const results = await applyDocumentFields(changes);
|
store.applyResults(results);
|
store.status = 'ready';
|
store.message = results.every((item) => item.ok) ? '已应用到文档' : '部分字段应用失败';
|
} catch (error) {
|
store.status = 'error';
|
store.message = error instanceof Error ? error.message : String(error);
|
}
|
}
|
async function previewSourceSync() {
|
if (!context || !canSynchronizeSource.value || store.status !== 'ready') return;
|
sourceSyncLoading.value = true;
|
store.status = 'working';
|
store.sourceSyncError = '';
|
try {
|
sourceSyncPreview.value = await requestSourceSyncPreview(context);
|
sourceSyncOperationCode = '';
|
store.message = sourceSyncPreview.value.changedCount ? '来源快照差异已加载' : '来源快照没有变化';
|
} catch (error) {
|
store.sourceSyncError = error instanceof Error ? error.message : String(error);
|
if (!invalidateUnauthorizedContext(error)) store.message = '来源快照差异加载失败';
|
} finally {
|
if (context) store.status = 'ready';
|
sourceSyncLoading.value = false;
|
}
|
}
|
function synchronizedValue(tag: string, data: FillDataResponse): FillFieldValue | undefined {
|
const source = data.fields[primaryFieldTag(tag) ?? ''];
|
const field = store.fields.find((item) => item.tag === tag);
|
if (!source || !field || source.type !== field.type) return undefined;
|
if (field.type === 'checkbox') return Boolean(source.value);
|
return typeof source.value === 'string' ? source.value : '';
|
}
|
function mergeSynchronizedFields(data: FillDataResponse, changedFieldCodes: Set<string>): FieldChange[] {
|
const changes: FieldChange[] = [];
|
for (const field of store.fields) {
|
const parsed = parseTag(field.tag);
|
if (!parsed || parsed.type === 'repeat' || !changedFieldCodes.has(parsed.fieldCode)) continue;
|
const value = synchronizedValue(field.tag, data);
|
if (value === undefined) throw new Error(`同步后填写数据缺少来源字段：${field.alias}`);
|
const metadata = data.fields[primaryFieldTag(field.tag) ?? ''];
|
field.draftValue = value;
|
field.required = metadata?.required === true;
|
field.requiredKnown = Boolean(metadata);
|
field.formulaStatus = metadata?.formulaStatus;
|
field.formulaMessage = metadata?.formulaMessage;
|
delete store.conflicts[field.tag];
|
// A metadata-only clear still needs a document save callback to confirm the operation.
|
changes.push({ tag: field.tag, type: field.type, value });
|
}
|
return changes;
|
}
|
async function synchronizeSource(clearReasons: Record<string, string> = {}) {
|
const preview = sourceSyncPreview.value;
|
if (!context || !preview || !canSynchronizeSource.value || store.status !== 'ready'
|
|| (!preview.changedCount && !Object.keys(clearReasons).length)) return;
|
sourceSyncLoading.value = true;
|
store.status = 'working';
|
store.sourceSyncError = '';
|
let synchronized = false;
|
try {
|
sourceSyncOperationCode ||= createOperationCode('source-sync');
|
const syncResult = await requestSourceSync(context, {
|
expectedRecordVersion: preview.recordVersion,
|
operationCode: sourceSyncOperationCode,
|
previewToken: preview.previewToken,
|
...(Object.keys(clearReasons).length ? { clearReasons } : {}),
|
});
|
synchronized = true;
|
const nextData = await fetchFillData(context);
|
const changedFieldCodes = new Set(syncResult.changedFieldCodes);
|
const changes = mergeSynchronizedFields(nextData, changedFieldCodes);
|
fillData = nextData;
|
if (changes.length) {
|
const results = await applyDocumentFields(changes);
|
store.applyResults(results);
|
if (!results.every((item) => item.ok)) {
|
throw new Error('部分来源字段写入文档失败，请重试应用');
|
}
|
}
|
store.formulaResultsStale = false;
|
sourceSyncPreview.value = null;
|
sourceSyncOperationCode = '';
|
store.message = '来源快照已写入文档，等待保存确认';
|
} catch (error) {
|
const message = error instanceof Error ? error.message : String(error);
|
store.sourceSyncError = synchronized ? `来源快照已同步，但${message}` : message;
|
if (!invalidateUnauthorizedContext(error)) {
|
store.message = synchronized ? '来源快照已同步，文档刷新失败' : '来源快照同步失败';
|
}
|
} finally {
|
if (context) store.status = 'ready';
|
sourceSyncLoading.value = false;
|
}
|
}
|
function createOperationCode(prefix = 'repeat'): string {
|
const uuid = globalThis.crypto?.randomUUID?.();
|
return `${prefix}-${uuid || `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`}`;
|
}
|
function repeatRowKey(groupCode: string, rowId: string): string {
|
return `${groupCode}\n${rowId}`;
|
}
|
function replaceRepeatRow(row: RepeatRow) {
|
const group = store.repeatGroups.find((item) => item.groupCode === row.groupCode);
|
if (!group) return;
|
const index = group.rows.findIndex((item) => item.rowId === row.rowId);
|
if (index >= 0) group.rows[index] = row;
|
else group.rows.push(row);
|
group.rows.sort((left, right) => left.rowOrder - right.rowOrder);
|
group.activeRowCount = group.rows.length;
|
}
|
async function applyPendingChanges(): Promise<void> {
|
if (conflictCount.value) throw new Error('请先处理字段冲突');
|
if (store.checkboxGroupError) throw new Error('请先处理选择组错误');
|
const changes = pendingChanges();
|
if (!changes.length) return;
|
const results = await applyDocumentFields(changes);
|
store.applyResults(results);
|
if (!results.every((item) => item.ok)) throw new Error('请先处理字段应用失败后再新增行');
|
}
|
async function appendRepeatRow(groupCode: string) {
|
if (!context?.canFill || context.bizScene !== RECORD_FILL_BIZ_SCENE || !groupCode || store.status !== 'ready') return;
|
store.status = 'working';
|
store.repeatError = '';
|
try {
|
await applyPendingChanges();
|
const operationCode = pendingRepeatOperations.get(groupCode) || createOperationCode();
|
pendingRepeatOperations.set(groupCode, operationCode);
|
const row = await requestRepeatRow(context, { groupCode, operationCode });
|
if (row.groupCode !== groupCode || !row.rowId) throw new Error('新增重复行响应与请求不一致');
|
await bridge.appendRepeatRow(groupCode, row.rowId);
|
const fields = await bridge.inspectFields();
|
replaceRepeatRow(row);
|
store.formulaResultsStale = true;
|
store.fields = buildDraftFields(fields, { ...fillData, repeatGroups: store.repeatGroups }, { ignoreDataValues: true });
|
store.refreshCheckboxGroupError();
|
store.fieldErrors = {};
|
store.repeatError = '';
|
pendingRepeatOperations.delete(groupCode);
|
store.status = 'ready';
|
store.message = `已新增第 ${row.rowOrder} 行`;
|
} catch (error) {
|
store.repeatError = error instanceof Error ? error.message : String(error);
|
if (!invalidateUnauthorizedContext(error)) {
|
store.status = 'ready';
|
store.message = '新增重复行失败，可重试';
|
}
|
}
|
}
|
async function deleteRepeatRow(groupCode: string, rowId: string, reason: string) {
|
if (!context?.canFill || context.bizScene !== RECORD_FILL_BIZ_SCENE || store.status !== 'ready') return;
|
const normalizedReason = reason.trim();
|
if (!normalizedReason) {
|
store.repeatError = '删除原因不能为空';
|
return;
|
}
|
store.status = 'working';
|
store.repeatError = '';
|
const key = repeatRowKey(groupCode, rowId);
|
const metadata = store.repeatGroups.find((group) => group.groupCode === groupCode)?.rows.find((row) => row.rowId === rowId);
|
const operationCode = pendingDeleteOperations.get(key) || metadata?.deleteOperationCode || createOperationCode();
|
pendingDeleteOperations.set(key, operationCode);
|
try {
|
await applyPendingChanges();
|
const prefix = `eln.repeat.${groupCode}.${rowId}.`;
|
const rowSnapshot = store.fields
|
.filter((field) => field.tag.startsWith(prefix))
|
.map((field) => ({ tag: field.tag, type: field.type, value: field.draftValue }));
|
const prepared = await requestDeleteRepeatRow(context, { groupCode, operationCode, reason: normalizedReason, rowId });
|
replaceRepeatRow(prepared);
|
store.formulaResultsStale = true;
|
try {
|
await bridge.removeRepeatRow(groupCode, rowId);
|
} catch (documentError) {
|
try {
|
const restored = await requestRestoreRepeatRow(context, { groupCode, operationCode, rowId });
|
replaceRepeatRow(restored);
|
} catch (restoreError) {
|
if (invalidateUnauthorizedContext(restoreError)) throw restoreError;
|
const restoreMessage = restoreError instanceof Error ? restoreError.message : String(restoreError);
|
throw new Error(`${documentError instanceof Error ? documentError.message : String(documentError)}；服务端恢复失败：${restoreMessage}`);
|
}
|
throw documentError;
|
}
|
pendingDeletedValues.set(key, rowSnapshot);
|
const fields = await bridge.inspectFields();
|
store.fields = buildDraftFields(fields, { ...fillData, repeatGroups: store.repeatGroups }, { ignoreDataValues: true });
|
store.refreshCheckboxGroupError();
|
store.status = 'ready';
|
store.message = '重复行已标记删除，保存文档后生效';
|
} catch (error) {
|
store.repeatError = error instanceof Error ? error.message : String(error);
|
if (!invalidateUnauthorizedContext(error)) {
|
store.status = 'ready';
|
store.message = '删除重复行失败，可重试';
|
}
|
}
|
}
|
async function restoreRepeatRow(groupCode: string, rowId: string) {
|
if (!context?.canFill || context.bizScene !== RECORD_FILL_BIZ_SCENE || store.status !== 'ready') return;
|
const metadata = store.repeatGroups.find((group) => group.groupCode === groupCode)?.rows.find((row) => row.rowId === rowId);
|
const operationCode = metadata?.deleteOperationCode || pendingDeleteOperations.get(repeatRowKey(groupCode, rowId));
|
if (!metadata || metadata.status !== 'DELETE_PREPARED' || !operationCode) {
|
store.repeatError = '待恢复重复行状态无效';
|
return;
|
}
|
store.status = 'working';
|
store.repeatError = '';
|
const key = repeatRowKey(groupCode, rowId);
|
try {
|
const prefix = `eln.repeat.${groupCode}.${rowId}.`;
|
if (!store.fields.some((field) => field.tag.startsWith(prefix))) {
|
const group = store.repeatGroups.find((item) => item.groupCode === groupCode);
|
const nextRow = group?.rows
|
.filter((row) => row.rowOrder > metadata.rowOrder && store.fields.some((field) => field.tag.startsWith(`eln.repeat.${groupCode}.${row.rowId}.`)))
|
.sort((left, right) => left.rowOrder - right.rowOrder)[0];
|
if (nextRow) await bridge.appendRepeatRow(groupCode, rowId, nextRow.rowId);
|
else await bridge.appendRepeatRow(groupCode, rowId);
|
const fields = await bridge.inspectFields();
|
const restoredFields = buildDraftFields(fields, fillData, { preferData: true });
|
const cachedValues = pendingDeletedValues.get(key);
|
let changes: FieldChange[];
|
if (cachedValues) {
|
changes = cachedValues
|
.map((change) => {
|
const field = restoredFields.find((item) => item.tag === change.tag && item.type === change.type);
|
if (!field) throw new Error('恢复重复行字段结构与删除前不一致');
|
field.draftValue = change.value;
|
return change;
|
})
|
.filter((change) => restoredFields.find((field) => field.tag === change.tag)?.documentValue !== change.value);
|
} else {
|
changes = restoredFields
|
.filter((field) => field.tag.startsWith(prefix) && field.draftValue !== field.documentValue)
|
.map((field) => ({ tag: field.tag, type: field.type, value: field.draftValue }));
|
}
|
if (changes.length) {
|
const results = await applyDocumentFields(changes);
|
store.fieldErrors = Object.fromEntries(results.filter((result) => !result.ok).map((result) => [result.tag, result.error || '应用失败']));
|
for (const result of results) {
|
const field = restoredFields.find((item) => item.tag === result.tag);
|
if (field && result.ok) field.documentValue = field.draftValue;
|
}
|
if (!results.every((item) => item.ok)) throw new Error('恢复重复行字段值失败');
|
}
|
store.fields = restoredFields;
|
store.refreshCheckboxGroupError();
|
}
|
const restored = await requestRestoreRepeatRow(context, { groupCode, operationCode, rowId });
|
replaceRepeatRow(restored);
|
store.formulaResultsStale = true;
|
pendingDeletedValues.delete(key);
|
pendingDeleteOperations.delete(key);
|
store.status = 'ready';
|
store.message = '重复行已恢复';
|
} catch (error) {
|
store.repeatError = error instanceof Error ? error.message : String(error);
|
if (!invalidateUnauthorizedContext(error)) {
|
store.status = 'ready';
|
store.message = '恢复重复行失败，可重试';
|
}
|
}
|
}
|
async function focusField(tag: string) {
|
const field = store.fields.find((item) => item.tag === tag);
|
if (!field) return;
|
try {
|
await bridge.selectControl(field.internalId);
|
store.focusedTag = field.tag;
|
selectFieldStep(field.tag);
|
store.documentSyncError = '';
|
} catch (error) {
|
store.documentSyncError = error instanceof Error ? error.message : String(error);
|
}
|
}
|
async function focusFirstFieldInStep(stepId: string) {
|
const structure = store.stepStructure;
|
if (!structure) return;
|
const field = store.fields.find((item) => {
|
const parsed = parseTag(item.tag);
|
return parsed && parsed.type !== 'reference' && assignedStepId(item.tag, structure) === stepId;
|
});
|
if (field) await focusField(field.tag);
|
}
|
const cleanup = bridge.bindLifecycle({
|
onControlChanged,
|
onControlFocused,
|
onReady: () => void initialize(),
|
onThemeChanged: () => undefined,
|
});
|
return {
|
store,
|
apply,
|
appendRepeatRow,
|
deleteRepeatRow,
|
dispose: () => {
|
clearTimeout(readyTimeout);
|
if (documentChangeTimer) clearTimeout(documentChangeTimer);
|
cleanup();
|
},
|
canFill: () => Boolean(context?.canFill),
|
canSynchronizeSource,
|
currentStepId,
|
conflictCount,
|
focusField,
|
focusFirstFieldInStep,
|
isMultiStep,
|
pendingCount,
|
recordHostState,
|
previewSourceSync,
|
selectStep: (stepId: string) => store.selectStep(stepId),
|
stepProgress,
|
sourceSyncLoading,
|
sourceSyncPreview,
|
synchronizeSource,
|
visibleFields,
|
visibleRepeatGroups,
|
canAppendRepeat: (groupCode?: string) => {
|
if (!context?.canFill || context.bizScene !== RECORD_FILL_BIZ_SCENE) return false;
|
const group = groupCode ? store.repeatGroups.find((item) => item.groupCode === groupCode) : undefined;
|
return !group || group.activeRowCount < group.maxRows;
|
},
|
restoreRepeatRow,
|
};
|
}
|
