e10-ebuilder-prototype 0.5.0

package/dist/workflow-runtime.mjs

@@ -0,0 +1,298 @@
+// Fixed local workflow state semantics. Business DOM, forms and visual layout are host-generated.
+function installWorkflowStore(templates) {
+    const clone = (value) => JSON.parse(JSON.stringify(value));
+    const catalog = new Map(templates.map((t) => [t.workflowId, t]));
+    const actor = {
+        id: 'demo-current-user',
+        name: '当前用户（模拟）',
+        subordinates: ['demo-subordinate'],
+    };
+    const empty = () => ({ schema: 1, records: [], comments: [], logs: [], favorites: [] });
+    const types = [
+        'todo',
+        'done',
+        'mine',
+        'share',
+        'subordinates',
+        'all',
+        'draft',
+        'monitor',
+        'newflow',
+    ];
+    let queue = Promise.resolve();
+    const serial = (fn) => {
+        const next = queue.then(fn);
+        queue = next.catch(() => { });
+        return next;
+    };
+    const validate = (state) => {
+        if (state?.schema !== 1 ||
+            !Array.isArray(state.records) ||
+            new Set(state.records.map((r) => r.id)).size !== state.records.length)
+            throw new Error('流程实例数据无效');
+        for (const { id, fields: f } of state.records) {
+            const template = catalog.get(f?.workflowId);
+            if (typeof id !== 'string' ||
+                !id ||
+                !template ||
+                template.objId !== f.objId ||
+                typeof f.recordId !== 'string' ||
+                !f.recordId ||
+                !['active', 'ended', 'draft'].includes(f.status) ||
+                !['pendingIds', 'handledBy', 'sharedWith', 'flags'].every((k) => Array.isArray(f[k])) ||
+                typeof f.initiatorId !== 'string')
+                throw new Error('流程实例与关联表单不匹配');
+        }
+        return state;
+    };
+    const load = async (initial = empty()) => validate(await E10FormStore.load(validate(initial)));
+    const save = async (state) => validate(await E10FormStore.save(validate(state)));
+    const belongs = (f, category) => {
+        const todo = f.status === 'active' && f.pendingIds.includes(actor.id);
+        switch (category) {
+            case 'todo':
+                return todo;
+            case 'done':
+                return f.status !== 'draft' && f.handledBy.includes(actor.id);
+            case 'mine':
+                return f.status !== 'draft' && f.initiatorId === actor.id;
+            case 'share':
+                return f.status !== 'draft' && f.sharedWith.includes(actor.id);
+            case 'subordinates':
+                return f.status === 'active' && f.pendingIds.some((id) => actor.subordinates.includes(id));
+            case 'draft':
+                return f.status === 'draft' && f.initiatorId === actor.id;
+            case 'all':
+                return f.status !== 'draft';
+            case 'monitor':
+                return f.status !== 'draft' && f.monitorable === true;
+            case 'newflow':
+                return false;
+            default:
+                return false;
+        }
+    };
+    const tabMatches = (f, tab) => {
+        if (!tab || tab === '全部')
+            return true;
+        if (tab === '待处理')
+            return (f.status === 'active' &&
+                (f.pendingIds.includes(actor.id) ||
+                    f.pendingIds.some((id) => actor.subordinates.includes(id))));
+        if (tab === '审批中')
+            return f.status === 'active';
+        if (tab === '已结束')
+            return f.status === 'ended';
+        if (tab === '未读')
+            return !f.read;
+        if (tab === '关注')
+            return !!f.followed;
+        if (tab === '已审批')
+            return f.handledBy.includes(actor.id);
+        return f.flags.includes(tab);
+    };
+    const filter = (state, category, options = {}) => {
+        if (!types.includes(category))
+            throw new Error('未知流程分类');
+        return validate(state).records.filter(({ fields: f }) => belongs(f, category) &&
+            tabMatches(f, options.tab) &&
+            (!options.state || options.state === '全部' || tabMatches(f, options.state)) &&
+            (!options.participation ||
+                options.participation === '全部' ||
+                [f.initiatorId, ...f.pendingIds, ...f.handledBy].includes(actor.id)) &&
+            (!options.search ||
+                `${f.title || ''} ${f.number || ''}`
+                    .toLowerCase()
+                    .includes(String(options.search).trim().toLowerCase())));
+    };
+    const log = (state, id, action) => {
+        state.logs ||= [];
+        state.logs.push({
+            instanceId: id,
+            action,
+            actor: actor.name,
+            at: new Date().toISOString(),
+            mockOnly: true,
+        });
+    };
+    const templateFor = (workflowId) => {
+        const template = catalog.get(workflowId);
+        if (!template)
+            throw new Error('流程模板未取得或不属于当前应用');
+        return template;
+    };
+    Object.defineProperty(window, 'E10WorkflowStore', {
+        configurable: true,
+        value: Object.freeze({
+            actor: clone(actor),
+            templates: clone(templates),
+            load,
+            filter,
+            async detail(instanceId) {
+                const state = await load(), instance = state.records.find((r) => r.id === instanceId);
+                if (!instance)
+                    throw new Error('流程实例不存在');
+                const form = await E10FormStore.forObject(instance.fields.objId).load(empty());
+                const record = form.records.find((r) => r.id === instance.fields.recordId);
+                if (!record)
+                    throw new Error('关联的本地表单记录不存在');
+                return clone({
+                    instance,
+                    record,
+                    template: templateFor(instance.fields.workflowId),
+                    comments: (state.comments || []).filter((c) => c.instanceId === instanceId),
+                    logs: (state.logs || []).filter((l) => l.instanceId === instanceId),
+                });
+            },
+            saveApplication({ workflowId, instanceId, record, title, draft = false }) {
+                return serial(async () => {
+                    const template = templateFor(workflowId), state = await load();
+                    let instance = instanceId ? state.records.find((r) => r.id === instanceId) : undefined;
+                    if (instanceId &&
+                        (!instance ||
+                            instance.fields.status !== 'draft' ||
+                            instance.fields.initiatorId !== actor.id ||
+                            instance.fields.workflowId !== workflowId))
+                        throw new Error('只能继续编辑自己的对应流程草稿');
+                    if (!record?.fields || typeof record.fields !== 'object' || Array.isArray(record.fields))
+                        throw new Error('表单字段无效');
+                    const id = instance?.id ||
+                        'wf-' +
+                            (globalThis.crypto?.randomUUID?.() ||
+                                Date.now() + '-' + Math.random().toString(36).slice(2));
+                    const recordId = instance?.fields.recordId || 'record-' + id;
+                    const form = await E10FormStore.forObject(template.objId).load(empty());
+                    const row = { ...clone(record), id: recordId }, position = form.records.findIndex((r) => r.id === recordId);
+                    if (instance && position < 0)
+                        throw new Error('草稿关联的表单记录已不存在');
+                    if (position >= 0)
+                        form.records[position] = row;
+                    else
+                        form.records.push(row);
+                    if (!instance) {
+                        instance = {
+                            id,
+                            fields: {
+                                workflowId,
+                                objId: template.objId,
+                                recordId,
+                                initiatorId: actor.id,
+                                initiator: actor.name,
+                                initiatedAt: new Date().toISOString(),
+                                number: 'MOCK-' + id.slice(-8),
+                                handledBy: [],
+                                sharedWith: [],
+                                flags: [],
+                                read: true,
+                                followed: false,
+                            },
+                        };
+                        state.records.push(instance);
+                    }
+                    Object.assign(instance.fields, {
+                        title: String(title || template.name),
+                        status: draft ? 'draft' : 'active',
+                        currentNode: draft ? '草稿' : '模拟审批节点',
+                        pendingIds: draft ? [] : ['demo-approver'],
+                        pendingNames: draft ? [] : ['审批人（模拟）'],
+                    });
+                    log(state, id, draft ? '保存草稿（模拟）' : '提交申请（模拟）');
+                    validate(state);
+                    await E10FormStore.commit([
+                        { objId: template.objId, value: form },
+                        { objId: 'workflow', value: state },
+                    ]);
+                    return clone(instance);
+                });
+            },
+            markRead(category) {
+                return serial(async () => {
+                    const state = await load(), rows = filter(state, category);
+                    for (const row of rows)
+                        row.fields.read = true;
+                    return save(state);
+                });
+            },
+            completeBatch(ids, confirmed = false, category = 'todo') {
+                return serial(async () => {
+                    const state = await load();
+                    if (!confirmed)
+                        return state;
+                    if (!Array.isArray(ids) || !ids.length || new Set(ids).size !== ids.length)
+                        throw new Error('请选择需要办理的流程');
+                    const available = filter(state, category), selected = ids.map((id) => available.find((r) => r.id === id));
+                    if (selected.some((r) => !r || r.fields.status !== 'active' || !r.fields.pendingIds.includes(actor.id)))
+                        throw new Error('所选流程包含当前用户不可办理的模拟记录');
+                    for (const row of selected) {
+                        row.fields.handledBy = [...new Set([...row.fields.handledBy, actor.id])];
+                        row.fields.pendingIds = ['demo-next-reviewer'];
+                        row.fields.pendingNames = ['下一节点处理人（模拟）'];
+                        row.fields.currentNode = '下一审批节点（模拟）';
+                        row.fields.read = true;
+                        log(state, row.id, '批量提交至下一节点（模拟）');
+                    }
+                    return save(state);
+                });
+            },
+            toggleFavorite(workflowId) {
+                return serial(async () => {
+                    templateFor(workflowId);
+                    const state = await load(), favorites = new Set(state.favorites || []);
+                    if (favorites.has(workflowId))
+                        favorites.delete(workflowId);
+                    else
+                        favorites.add(workflowId);
+                    state.favorites = [...favorites];
+                    return save(state);
+                });
+            },
+            toggleFollow(instanceId) {
+                return serial(async () => {
+                    const state = await load(), row = state.records.find((r) => r.id === instanceId);
+                    if (!row)
+                        throw new Error('流程实例不存在');
+                    row.fields.followed = !row.fields.followed;
+                    return save(state);
+                });
+            },
+            comment(instanceId, text) {
+                return serial(async () => {
+                    const state = await load();
+                    if (!state.records.some((r) => r.id === instanceId) || !String(text).trim())
+                        throw new Error('请选择流程并填写评论');
+                    state.comments ||= [];
+                    state.comments.push({
+                        instanceId,
+                        text: String(text).trim().slice(0, 5000),
+                        actor: actor.name,
+                        at: new Date().toISOString(),
+                        mockOnly: true,
+                    });
+                    return save(state);
+                });
+            },
+            reset(initial, forms = [], confirmed = false) {
+                return serial(async () => {
+                    if (!confirmed)
+                        return load();
+                    validate(initial);
+                    if (forms.some((f) => !templates.some((t) => t.objId === f.objId)))
+                        throw new Error('重置包含无关表单');
+                    await E10FormStore.commit([...forms, { objId: 'workflow', value: initial }]);
+                    return clone(initial);
+                });
+            },
+        }),
+    });
+}
+export function workflowRuntime(templates) {
+    const json = JSON.stringify(templates)
+        .replaceAll('<', '\\u003c')
+        .replaceAll('\u2028', '\\u2028')
+        .replaceAll('\u2029', '\\u2029');
+    return `<script id="e10-workflow-runtime">(${installWorkflowStore.toString()})(${json});</script>`;
+}
+export function attachWorkflowRuntime(source, templates) {
+    const clean = source.replace(/<script\b[^>]*\bid\s*=\s*["']e10-workflow-runtime["'][^>]*>[\s\S]*?<\/script\s*>/gi, '');
+    return clean.replace(/(<script id="e10-form-runtime">[\s\S]*?<\/script>)/, (match) => match + workflowRuntime(templates));
+}

package/dist/workflows.d.ts

@@ -0,0 +1,28 @@
+import type { WorkflowType } from './model.js';
+export declare const WORKFLOW_TYPES: WorkflowType[];
+export declare const APPROVAL_PATH = "/api/bs/ebuilder/flow/approval/getApprovalListDatasByAppId";
+export declare function workflowType(value: unknown): WorkflowType;
+export interface WorkflowTemplate {
+    workflowId: string;
+    name: string;
+    objId: string;
+    formName: string;
+    formId: string;
+    status?: unknown;
+    groupId: string;
+    groupName?: string;
+}
+export interface WorkflowCatalog {
+    status: 'ready';
+    source: string;
+    rawCount: number;
+    templates: WorkflowTemplate[];
+    skipped: {
+        index: number;
+        name?: string;
+        reason: string;
+    }[];
+}
+/** E10Client has removed the outer envelope; its data.data array remains here. */
+export declare function normalizeWorkflows(data: any, appId: string, objectIds: Set<string>): WorkflowCatalog;
+export declare function workflowPreset(type: WorkflowType): any;

package/dist/workflows.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import { CaptureError } from './common.js';
+export const WORKFLOW_TYPES = [
+    'todo',
+    'done',
+    'mine',
+    'share',
+    'subordinates',
+    'all',
+    'draft',
+    'monitor',
+    'newflow',
+];
+export const APPROVAL_PATH = '/api/bs/ebuilder/flow/approval/getApprovalListDatasByAppId';
+export function workflowType(value) {
+    if (!WORKFLOW_TYPES.includes(value))
+        throw new CaptureError('WORKFLOW_TYPE_UNSUPPORTED', '不支持的流程菜单分类');
+    return value;
+}
+/** E10Client has removed the outer envelope; its data.data array remains here. */
+export function normalizeWorkflows(data, appId, objectIds) {
+    if (!data || !Array.isArray(data.data))
+        throw new CaptureError('WORKFLOW_CATALOG_INVALID', '流程目录响应缺少 data.data 数组');
+    const catalog = {
+        status: 'ready',
+        source: APPROVAL_PATH,
+        rawCount: data.data.length,
+        templates: [],
+        skipped: [],
+    };
+    const seen = new Map();
+    const decimal = (v) => (typeof v === 'string' || (typeof v === 'number' && Number.isSafeInteger(v))) &&
+        /^[0-9]+$/.test(String(v)) &&
+        /[1-9]/.test(String(v));
+    for (const [index, raw] of data.data.entries()) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new CaptureError('WORKFLOW_CATALOG_INVALID', '流程目录包含无效配置');
+        const dataset = raw.dataset || {};
+        let reason;
+        if ([true, 1, '1', 'true'].includes(raw.nonEbForm))
+            reason = 'non-eb-form-not-supported';
+        else if (!decimal(raw.workflowid) || !decimal(raw.objId))
+            reason = 'invalid-workflow-or-object-id';
+        else if (typeof dataset !== 'object' || Array.isArray(dataset))
+            reason = 'invalid-workflow-dataset';
+        else if (dataset.id != null && String(dataset.id) !== String(raw.objId))
+            reason = 'workflow-dataset-objId-conflict';
+        else if ((dataset.appId != null && String(dataset.appId) !== appId) ||
+            (raw.appId != null && String(raw.appId) !== appId) ||
+            !objectIds.has(String(raw.objId)))
+            reason = 'workflow-target-app-context-required';
+        else if (dataset.type != null && dataset.type !== 'FORM')
+            reason = 'workflow-dataset-not-form';
+        if (reason) {
+            catalog.skipped.push({ index, name: raw.workflowname, reason });
+            continue;
+        }
+        const workflowId = String(raw.workflowid), serialized = JSON.stringify(raw);
+        if (seen.has(workflowId)) {
+            if (seen.get(workflowId) !== serialized)
+                throw new CaptureError('WORKFLOW_CATALOG_CONFLICT', '重复流程 ID 对应不同配置');
+            continue;
+        }
+        seen.set(workflowId, serialized);
+        catalog.templates.push({
+            workflowId,
+            name: String(raw.workflowname || dataset.text || workflowId),
+            objId: String(raw.objId),
+            formName: String(dataset.text || raw.objId),
+            formId: String(raw.formid || ''),
+            status: raw.status,
+            groupId: String(raw.groupId ?? ''),
+            ...(typeof raw.groupName === 'string' && raw.groupName.trim() && String(raw.groupId) !== '-1'
+                ? { groupName: raw.groupName }
+                : {}),
+        });
+    }
+    return catalog;
+}
+export function workflowPreset(type) {
+    const presets = JSON.parse(fs.readFileSync(new URL('./templates/workflow-presets.json', import.meta.url), 'utf8'));
+    const { extends: parent, ...entry } = presets[workflowType(type)];
+    return {
+        ...(parent ? presets[parent] : {}),
+        ...entry,
+        workflowType: type,
+        source: 'prototype-workflow-preset',
+        mockOnly: true,
+    };
+}