e10-ebuilder-prototype 0.5.0

package/dist/menus.js

@@ -0,0 +1,330 @@
+import { CaptureError, id } from './common.js';
+import { E10Client, parseApiJson } from './api.js';
+import { parseApp, parseForms, parsePages } from './platform.js';
+import { workflowType } from './workflows.js';
+export function navigationKey(value) {
+    if (!/^\d+(?:-\d+)*$/.test(value) || value.length > 240)
+        throw new CaptureError('MENU_KEY_INVALID', '菜单标识无效');
+    return value;
+}
+const decimal = (value) => id(typeof value === 'number' && Number.isSafeInteger(value) ? String(value) : value);
+const object = (value) => {
+    if (value == null || value === '')
+        return {};
+    const result = typeof value === 'string' ? parseApiJson(value) : value;
+    if (!result || typeof result !== 'object' || Array.isArray(result))
+        throw new CaptureError('MENU_CONFIG_INVALID', '菜单配置必须为对象');
+    return result;
+};
+function urlTarget(value, origin, appId) {
+    if (typeof value !== 'string' || !value)
+        return;
+    if (!value.startsWith('/') && !/^https?:\/\//.test(value))
+        return;
+    const url = new URL(value, origin);
+    if (!['http:', 'https:'].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        /[\\\r\n]/.test(value))
+        throw new CaptureError('MENU_URL_INVALID', '菜单地址无效');
+    let match = url.pathname.match(/^\/sp\/ebdpage\/view\/(\d+)(?:\/page\/\1)?\/?$/);
+    if (match)
+        return { kind: 'page', pageId: match[1] };
+    match = url.pathname.match(/^\/sp\/appbuilder\/combinedpage_preview\/(\d+)(?:\/(\d+))?\/?$/);
+    if (match)
+        return { kind: 'combined', appId: match[1], combinationId: match[2] };
+    match = url.pathname.match(/^\/sp\/ebdfpage\/workflow\/(\d+)_([a-z]+)\/?$/);
+    if (match) {
+        if (match[1] !== appId)
+            throw new CaptureError('MENU_APP_MISMATCH', '流程菜单指向其它应用');
+        for (const [key, expected] of [
+            ['appId', appId],
+            ['pageId', match[2]],
+        ])
+            if (url.searchParams.getAll(key).some((value) => value !== expected))
+                throw new CaptureError('MENU_URL_CONFLICT', '流程菜单类型或应用 ID 冲突');
+        return { kind: 'workflow', workflowType: workflowType(match[2]) };
+    }
+    match = url.pathname.match(/^\/sp\/ebdfpage\/(list|search|viewport)\/(?:(\d+)_)?(\d+)\/?$/);
+    let target;
+    if (match) {
+        if (match[2] && match[2] !== appId)
+            throw new CaptureError('MENU_APP_MISMATCH', '列表菜单指向其它应用');
+        target = { kind: match[1] === 'viewport' ? 'nlist' : 'list', viewId: match[3] };
+    }
+    else {
+        match = url.pathname.match(/^\/sp\/ebdfpage\/card\/([012])\/(\d+)\/(\d+)\/?$/);
+        if (match)
+            target = {
+                kind: 'layout',
+                objId: match[2],
+                mode: { '0': 'view', '1': 'add', '2': 'edit' }[match[1]],
+                recordId: match[3],
+                layoutId: '',
+            };
+    }
+    if (!target)
+        return;
+    for (const key of ['appId', 'objId', 'listId', 'pageId', 'layoutId']) {
+        const values = url.searchParams.getAll(key);
+        if (!values.length)
+            continue;
+        if (new Set(values).size !== 1)
+            throw new CaptureError('MENU_URL_CONFLICT', `菜单 ${key} 冲突`);
+        const value = decimal(values[0]);
+        if (key === 'appId' && value !== appId)
+            throw new CaptureError('MENU_APP_MISMATCH', '菜单指向其它应用');
+        if ((key === 'listId' || key === 'pageId') &&
+            target.kind !== 'layout' &&
+            target.viewId !== value)
+            throw new CaptureError('MENU_URL_CONFLICT', '菜单列表 ID 冲突');
+        if (key === 'objId') {
+            if (target.objId && target.objId !== value)
+                throw new CaptureError('MENU_URL_CONFLICT', '菜单表单 ID 冲突');
+            target.objId = value;
+        }
+        if (key === 'layoutId' && target.kind === 'layout')
+            target.layoutId = value;
+    }
+    return target;
+}
+function targetFor(raw, origin, appId) {
+    const type = String(raw.pageType || '').toUpperCase();
+    const direct = urlTarget(raw.menuUrl || (type === 'LINK' ? raw.pageId : undefined), origin, appId);
+    const alternate = type === 'LINK' && raw.menuUrl ? urlTarget(raw.pageId, origin, appId) : undefined;
+    if (alternate && direct && JSON.stringify(alternate) !== JSON.stringify(direct))
+        throw new CaptureError('MENU_URL_CONFLICT', 'LINK 菜单的两个目标地址冲突');
+    if (direct?.kind === 'combined') {
+        if (direct.appId !== appId)
+            throw new CaptureError('MENU_APP_MISMATCH', '组合菜单指向其它应用');
+        const declared = raw.combinationId && String(raw.combinationId) !== '0'
+            ? decimal(raw.combinationId)
+            : undefined;
+        if (declared && direct.combinationId && declared !== direct.combinationId)
+            throw new CaptureError('MENU_URL_CONFLICT', '组合页面 ID 冲突');
+        return { ...direct, combinationId: declared || direct.combinationId };
+    }
+    const remote = String(raw.remoteAppId || raw.appId || '0');
+    if (remote !== '0' && remote !== appId)
+        throw new CaptureError('MENU_APP_MISMATCH', '菜单指向其它应用');
+    let declared;
+    if (type === 'WORKFLOW')
+        declared = { kind: 'workflow', workflowType: workflowType(raw.pageId) };
+    if (type === 'PAGE')
+        declared = { kind: 'page', pageId: decimal(raw.pageId) };
+    if (type === 'SEARCH')
+        declared = { kind: 'list', viewId: decimal(raw.pageId) };
+    if (type === 'VIEWPORT') {
+        const tabs = object(raw.tabs);
+        if (tabs.pageViewType && String(tabs.pageViewType).toLowerCase() !== 'nlist')
+            return;
+        declared = { kind: 'nlist', viewId: decimal(raw.pageId) };
+    }
+    if (type === 'LAYOUT') {
+        const match = String(raw.pageId).match(/^([012])[_/](\d+)$/);
+        if (!match)
+            throw new CaptureError('MENU_LAYOUT_INVALID', '布局菜单的 pageId 无法识别');
+        declared = {
+            kind: 'layout',
+            objId: match[2],
+            mode: { '0': 'view', '1': 'add', '2': 'edit' }[match[1]],
+        };
+    }
+    if (direct && declared) {
+        if (direct.kind !== declared.kind ||
+            ['pageId', 'viewId', 'objId', 'mode', 'workflowType'].some((key) => direct[key] &&
+                declared[key] &&
+                direct[key] !== declared[key]))
+            throw new CaptureError('MENU_URL_CONFLICT', '菜单类型或 ID 与地址冲突');
+    }
+    const target = direct || declared;
+    if (target?.kind === 'layout') {
+        const layout = raw.selectLayout;
+        const layoutId = layout == null ||
+            ['', '{}', 'null'].includes(String(layout)) ||
+            (typeof layout === 'object' && !Object.keys(layout).length)
+            ? ''
+            : decimal(layout);
+        if (layoutId && target.layoutId && layoutId !== target.layoutId)
+            throw new CaptureError('MENU_URL_CONFLICT', '布局 ID 冲突');
+        target.layoutId = layoutId || target.layoutId || '';
+    }
+    return target;
+}
+export function parseMenus(data, appId, origin, prefix = '') {
+    if (!data || typeof data !== 'object' || (data.id != null && String(data.id) !== appId))
+        throw new CaptureError('MENUS_INVALID', '菜单应用信息无效');
+    const rows = data.ebAppMenus ?? data.cusAppMenus;
+    if (!Array.isArray(rows))
+        throw new CaptureError('MENUS_INVALID', '菜单接口缺少菜单数组');
+    const skipped = [], forms = [];
+    const nodes = new Map();
+    const visit = (items, parent = '0') => {
+        for (const raw of items) {
+            if (!raw || typeof raw !== 'object')
+                throw new CaptureError('MENUS_INVALID', '菜单项无效');
+            const menuId = decimal(raw.id), key = navigationKey(prefix ? `${prefix}-${menuId}` : menuId);
+            if (nodes.has(menuId))
+                throw new CaptureError('MENU_DUPLICATE', `重复菜单 ${menuId}`);
+            const name = raw.menuName || raw.content || raw.showName || raw.pageName || menuId;
+            if (typeof name !== 'string')
+                throw new CaptureError('MENUS_INVALID', '菜单名称无效');
+            const order = Number(raw.showOrder ?? raw.sort ?? nodes.size);
+            if (!Number.isFinite(order))
+                throw new CaptureError('MENUS_INVALID', '菜单顺序无效');
+            const node = {
+                id: key,
+                menuId,
+                name,
+                order,
+                default: raw.defaultMenuSelect === true,
+                icon: raw.icon,
+                openMode: raw.openMode,
+                params: raw.pageParam ?? raw.params,
+                children: [],
+            };
+            const type = String(raw.pageType || '').toUpperCase();
+            const excluded = ['SETTING', 'SETTINGS'].includes(type) ||
+                (type === 'BASE' && String(raw.pageId).toLowerCase() === 'recycle');
+            const denied = [true, 1, '1'].includes(raw.noPermissionMenu);
+            const target = excluded || denied ? undefined : targetFor(raw, origin, appId);
+            if (!target)
+                skipped.push({
+                    id: key,
+                    name,
+                    type,
+                    reason: denied
+                        ? 'no-permission'
+                        : excluded
+                            ? 'excluded-system-menu'
+                            : 'unsupported-menu-type',
+                });
+            if (target?.kind === 'page')
+                node.target = { kind: 'page', id: target.pageId };
+            else if (target?.kind === 'combined')
+                node.target = { kind: 'combined', id: key };
+            else if (target) {
+                forms.push({
+                    ...target,
+                    id: key,
+                    menuId,
+                    name,
+                    appId,
+                    params: node.params,
+                    openMode: node.openMode,
+                });
+                node.target = { kind: 'form', id: key };
+            }
+            nodes.set(menuId, {
+                node,
+                parent: String(raw.pid ?? raw.parentId ?? parent),
+                blocked: excluded || denied,
+                target,
+            });
+            if (Array.isArray(raw.children) && !excluded && !denied)
+                visit(raw.children, menuId);
+        }
+    };
+    visit(rows);
+    const roots = [];
+    for (const entry of nodes.values()) {
+        let cursor = entry.parent;
+        const seen = new Set([entry.node.menuId]);
+        while (nodes.has(cursor)) {
+            if (seen.has(cursor))
+                throw new CaptureError('MENU_CYCLE', '菜单父子关系循环');
+            seen.add(cursor);
+            cursor = nodes.get(cursor).parent;
+        }
+        if (nodes.has(entry.parent))
+            nodes.get(entry.parent).node.children.push(entry.node);
+        else
+            roots.push(entry.node);
+    }
+    const prune = (items) => items
+        .filter((node) => !nodes.get(node.menuId).blocked)
+        .map((node) => ({ ...node, children: prune(node.children) }))
+        .filter((node) => node.target || node.children.length)
+        .sort((a, b) => a.order - b.order);
+    const menus = prune(roots), retained = new Set(menuItems(menus).map((node) => node.id));
+    for (const entry of nodes.values())
+        if (!retained.has(entry.node.id) && entry.node.target)
+            skipped.push({
+                id: entry.node.id,
+                name: entry.node.name,
+                type: entry.node.target.kind,
+                reason: 'excluded-parent-menu',
+            });
+    const groups = new Set(menuItems(menus)
+        .filter((node) => !node.target && node.children.length)
+        .map((node) => node.id));
+    return {
+        menus,
+        forms: forms.filter((form) => retained.has(form.id)),
+        skipped: skipped.filter((item) => !groups.has(item.id)),
+        combinations: [...nodes.values()]
+            .filter((e) => retained.has(e.node.id) && e.target?.kind === 'combined')
+            .map((e) => ({ key: e.node.id, target: e.target })),
+    };
+}
+export function menuItems(menus) {
+    return menus.flatMap((node) => [node, ...menuItems(node.children), ...menuItems(node.tabs || [])]);
+}
+export async function discoverMenus(auth, appId) {
+    const client = new E10Client(auth);
+    const responses = await Promise.allSettled([
+        client.request('GET', `/api/cusapp/app/allMenus?appId=${appId}&terminalType=PC&isFront=0`),
+        client.request('GET', `/api/bs/ebuilder/app/info?id=${appId}`),
+    ]);
+    for (const result of responses)
+        if (result.status === 'rejected')
+            throw result.reason;
+    const [raw, app] = responses.map((result) => result.value);
+    const appName = parseApp({ code: 200, data: app }, appId);
+    const parsed = parseMenus(raw, appId, client.origin);
+    for (const combination of parsed.combinations) {
+        const node = menuItems(parsed.menus).find((n) => n.id === combination.key);
+        const data = await client.request('GET', `/api/cusapp/app/getCombMenus?appId=${appId}&pid=${node.menuId}&type=1&terminalType=PC&showType=0&isComb=0&isFront=0`);
+        if (String(data?.appId) !== appId ||
+            !Array.isArray(data.menuEntities) ||
+            (combination.target.combinationId && String(data.id) !== combination.target.combinationId))
+            throw new CaptureError('COMBINED_INVALID', '组合菜单归属或结构无效');
+        const tabs = parseMenus({ id: appId, ebAppMenus: data.menuEntities }, appId, client.origin, node.id);
+        if (tabs.combinations.length)
+            throw new CaptureError('COMBINED_NESTED', '暂不支持嵌套组合页面');
+        if (!tabs.menus.length)
+            throw new CaptureError('COMBINED_EMPTY', '组合菜单没有受支持的页面或列表');
+        node.tabs = tabs.menus;
+        parsed.forms.push(...tabs.forms);
+        parsed.skipped.push(...tabs.skipped);
+    }
+    const pageIds = new Set(menuItems(parsed.menus)
+        .filter((n) => n.target?.kind === 'page')
+        .map((n) => n.target.id));
+    const metadata = await Promise.allSettled([
+        pageIds.size
+            ? client.request('GET', `/api/bs/ebuilder/page/list?appid=${appId}`)
+            : Promise.resolve([]),
+        parsed.forms.length
+            ? client.request('GET', `/api/bs/ebuilder/form/obj/getList/${appId}?apid=${appId}`)
+            : Promise.resolve([]),
+    ]);
+    for (const result of metadata)
+        if (result.status === 'rejected')
+            throw result.reason;
+    const [pagesRaw, formsRaw] = metadata.map((result) => result.value);
+    if (!Array.isArray(pagesRaw))
+        throw new CaptureError('PAGE_LIST_INVALID', '页面清单无效');
+    const pages = parsePages({ code: 200, data: pagesRaw.filter((p) => pageIds.has(String(p?.id))) }, appId, client.origin);
+    if (pages.length !== pageIds.size)
+        throw new CaptureError('MENU_PAGE_MISSING', '已发布菜单对应的页面不在当前应用中');
+    const byId = new Map(pages.map((page) => [page.id, page]));
+    return {
+        appName,
+        menus: parsed.menus,
+        skippedMenus: parsed.skipped,
+        pages: [...pageIds].map((id) => byId.get(id)),
+        forms: parseForms({ code: 200, data: formsRaw }, appId, client.origin),
+        formPages: parsed.forms,
+    };
+}

package/dist/model.d.ts

@@ -0,0 +1,164 @@
+export interface PageItem {
+    id: string;
+    name: string;
+    appId: string;
+    url: string;
+    terminal: 'PC' | 'MOBILE';
+    type?: 'PAGE' | 'ECODE_HTML' | 'ECODE_REACT';
+}
+export interface FormItem {
+    id: string;
+    name: string;
+    appId: string;
+    url: string;
+}
+export interface MenuItem {
+    /** A navigation key; combined children include their container's key. */
+    id: string;
+    menuId: string;
+    name: string;
+    order: number;
+    default: boolean;
+    icon?: unknown;
+    openMode?: unknown;
+    params?: unknown;
+    target?: {
+        kind: 'page' | 'form' | 'combined';
+        id: string;
+    };
+    children: MenuItem[];
+    tabs?: MenuItem[];
+}
+export interface SkippedMenu {
+    id: string;
+    name: string;
+    type: string;
+    reason: string;
+}
+export type WorkflowType = 'todo' | 'done' | 'mine' | 'share' | 'subordinates' | 'all' | 'draft' | 'monitor' | 'newflow';
+export interface FormPage {
+    id: string;
+    menuId: string;
+    name: string;
+    appId: string;
+    kind: 'list' | 'nlist' | 'layout' | 'workflow';
+    workflowType?: WorkflowType;
+    viewId?: string;
+    objId?: string;
+    layoutId?: string;
+    mode?: 'view' | 'add' | 'edit';
+    recordId?: string;
+    params?: unknown;
+    openMode?: unknown;
+}
+export interface FormCollection {
+    id: string;
+    status: 'running' | 'succeeded' | 'failed';
+    attempt: number;
+    updatedAt: string;
+    objId?: string;
+    kind?: 'workflow';
+    objectIds?: string[];
+    sha256?: string;
+    warnings?: string[];
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface Settings {
+    concurrency: number;
+    width: number;
+    height: number;
+    timeoutMs: number;
+    stableMs: number;
+    retries: number;
+}
+export declare const defaults: Settings;
+export interface TaskState {
+    schema: 1;
+    version: string;
+    appId: string;
+    createdAt: string;
+    requestedOrigin?: string;
+    allowTemporaryRecords?: boolean;
+    settings: Settings;
+    environment?: {
+        origin: string;
+        identityHash: string;
+    };
+    pages?: PageItem[];
+    discoveredAt?: string;
+    htmlRequired?: boolean;
+    siteRequired?: boolean;
+    appName?: string;
+    forms?: FormItem[];
+    /** Absent on legacy tasks, which retain their original discovery/placeholder flow. */
+    menuRequired?: boolean;
+    menus?: MenuItem[];
+    formPages?: FormPage[];
+    skippedMenus?: SkippedMenu[];
+    archive?: {
+        path: string;
+        sha256: string;
+        completedAt: string;
+        partial: boolean;
+        site?: {
+            entry: string;
+            files: {
+                path: string;
+                sha256: string;
+            }[];
+        };
+    };
+}
+export interface HtmlResult {
+    id: string;
+    kind?: 'page' | 'form';
+    status: 'running' | 'succeeded' | 'failed';
+    token: string;
+    attempt: number;
+    sourceSha256: string;
+    promptVersion: 1 | 2 | 3 | 4 | 5;
+    startedAt: string;
+    finishedAt?: string;
+    file?: string;
+    sha256?: string;
+    bytes?: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface Attempt {
+    number: number;
+    stage: string;
+    startedAt: string;
+    finishedAt?: string;
+    elapsedMs?: number;
+    status: 'running' | 'succeeded' | 'failed';
+    error?: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+    diagnostic?: string;
+    evidence?: unknown;
+    cleanupError?: string;
+}
+export interface PageResult {
+    id: string;
+    name: string;
+    url: string;
+    status: 'running' | 'succeeded' | 'failed';
+    history: Attempt[];
+    warnings?: {
+        code: string;
+        message: string;
+    }[];
+    file?: string;
+    sha256?: string;
+    width?: number;
+    height?: number;
+    bytes?: number;
+}

package/dist/model.js

@@ -0,0 +1,8 @@
+export const defaults = {
+    concurrency: 4,
+    width: 1440,
+    height: 900,
+    timeoutMs: 10000,
+    stableMs: 800,
+    retries: 1,
+};

package/dist/offline-store.d.mts

@@ -0,0 +1,5 @@
+export function createOfflineStorage(appId: any): {
+    valid: (value: any) => any;
+    operate(scope: any, operation: any, value: any): any;
+    commit(entries: any): any;
+};

package/dist/offline-store.mjs

@@ -0,0 +1,80 @@
+// Shared by the shell and standalone transport. A linked workflow/form commit is one
+// localStorage replacement; unavailable storage keeps the whole transaction in memory.
+export function createOfflineStorage(appId) {
+    const key = 'e10-prototype:v2:' + appId;
+    let memory = { schema: 2, objects: {} }, volatile = false;
+    const clone = (value) => JSON.parse(JSON.stringify(value));
+    const valid = (value) => value?.schema === 1 &&
+        Array.isArray(value.records) &&
+        value.records.every((row) => row &&
+            typeof row.id === 'string' &&
+            row.fields &&
+            typeof row.fields === 'object' &&
+            !Array.isArray(row.fields));
+    const check = (scope, value) => {
+        if (!scope.startsWith(appId + ':') ||
+            !/^\d+:(?:\d+|workflow)$/.test(scope) ||
+            !valid(value) ||
+            JSON.stringify(value).length > 2_000_000)
+            throw new Error('本地数据范围、格式或容量无效');
+    };
+    const read = () => {
+        if (!volatile)
+            try {
+                const stored = JSON.parse(localStorage.getItem(key));
+                if (stored?.schema === 2 &&
+                    stored.objects &&
+                    typeof stored.objects === 'object' &&
+                    !Array.isArray(stored.objects))
+                    memory = stored;
+            }
+            catch { }
+        return clone(memory);
+    };
+    const persist = (next) => {
+        try {
+            localStorage.setItem(key, JSON.stringify(next));
+            volatile = false;
+        }
+        catch {
+            volatile = true;
+        }
+        memory = next;
+    };
+    return {
+        valid,
+        operate(scope, operation, value) {
+            check(scope, value);
+            if (!['load', 'save', 'reset'].includes(operation))
+                throw new Error('未知本地操作');
+            const next = read();
+            if (operation === 'load' && !valid(next.objects[scope])) {
+                try {
+                    const previous = JSON.parse(localStorage.getItem('e10-prototype:v1:' + scope));
+                    if (valid(previous))
+                        next.objects[scope] = previous;
+                }
+                catch { }
+            }
+            if (operation !== 'load' || !valid(next.objects[scope]))
+                next.objects[scope] = clone(value);
+            persist(next);
+            return clone(next.objects[scope]);
+        },
+        commit(entries) {
+            if (!Array.isArray(entries) ||
+                !entries.length ||
+                entries.length > 100 ||
+                new Set(entries.map((e) => e.scope)).size !== entries.length ||
+                JSON.stringify(entries).length > 2_000_000)
+                throw new Error('本地联合保存参数无效');
+            for (const entry of entries)
+                check(entry.scope, entry.value);
+            const next = read();
+            for (const entry of entries)
+                next.objects[entry.scope] = clone(entry.value);
+            persist(next);
+            return clone(entries);
+        },
+    };
+}

package/dist/platform.d.ts

@@ -0,0 +1,10 @@
+import type { PageItem, FormItem } from './model.js';
+import type { E10AuthContext } from './vendor/environment-auth.js';
+export declare function parsePages(payload: unknown, appId: string, origin: string): PageItem[];
+export declare function parseApp(payload: unknown, appId: string): string;
+export declare function parseForms(payload: unknown, appId: string, origin: string): FormItem[];
+export declare function fetchCatalog(auth: E10AuthContext, appId: string): Promise<{
+    appName: string;
+    forms: FormItem[];
+}>;
+export declare function fetchPages(auth: E10AuthContext, appId: string): Promise<PageItem[]>;