@lesliechan721/aw 0.1.0-beta.3

package/dist/src/tui/model.js

@@ -0,0 +1,652 @@
+function compareText(left, right) {
+    return left.localeCompare(right, 'en');
+}
+function targetHealth(target) {
+    if (target.state === 'present')
+        return 'ready';
+    if (target.state === 'partial')
+        return 'incomplete';
+    return 'error';
+}
+function isInstalledScopeEvidence(target) {
+    return target.state === 'present' || target.state === 'partial';
+}
+function dependencyPluginIdFromMessage(message) {
+    return message.match(/(?:[a-z0-9]+(?:-[a-z0-9]+)*)\/(?:[a-z0-9]+(?:-[a-z0-9]+)*)/u)?.[0];
+}
+export function projectPlatformPlacement(platform, targets) {
+    const supportedScopes = [...new Set(targets.map((target) => target.scope))];
+    const installed = targets.filter(isInstalledScopeEvidence);
+    if (installed.length === 0) {
+        const errorTarget = targets.find((target) => target.state === 'error');
+        if (!errorTarget)
+            return { platform, state: 'notInstalled', supportedScopes };
+        return { platform, state: 'installed', scope: errorTarget.scope, health: 'error' };
+    }
+    if (installed.length === 1) {
+        const target = installed[0];
+        return { platform, state: 'installed', scope: target.scope, health: targetHealth(target) };
+    }
+    return {
+        platform,
+        state: 'scopeConflict',
+        placements: installed.map((target) => ({
+            scope: target.scope,
+            health: targetHealth(target),
+        })).sort((left, right) => compareText(left.scope, right.scope)),
+    };
+}
+export function hasInstalledPlacement(plugin) {
+    return plugin.installedPlacements.some((placement) => placement.state !== 'notInstalled');
+}
+function sourceState(source, health) {
+    if (health?.state === 'ready')
+        return 'ready';
+    if (health?.state === 'path')
+        return 'path';
+    if (health?.state === 'degraded')
+        return 'cache';
+    if (health?.state === 'unavailable')
+        return 'error';
+    if (source.error)
+        return 'error';
+    if (source.type === 'path' || source.freshness === 'path')
+        return 'path';
+    return source.freshness === 'cache' ? 'cache' : 'ready';
+}
+function sourceIssue(health, impactedTargets = 0) {
+    if (health.state !== 'cache' && health.state !== 'degraded' && health.state !== 'unavailable')
+        return undefined;
+    const cached = health.state === 'cache' || health.state === 'degraded';
+    const issueId = health.issueId ?? `source:${health.sourceId}:${cached ? 'cache' : 'unavailable'}`;
+    return {
+        issueId,
+        category: cached ? 'sourceDegraded' : 'sourceUnavailable',
+        title: `${health.sourceId} · ${cached ? '来源使用缓存' : '来源不可用'}`,
+        explanation: cached
+            ? '远端检查失败。当前仍使用已验证的缓存数据。'
+            : '远端检查失败，并且没有可用缓存数据。',
+        impact: [cached ? '插件仍可浏览，但数据可能不是最新。' : '当前不能浏览或安装这个来源的插件。',
+            ...(impactedTargets > 0 ? [`${impactedTargets} 个安装位置受此来源根问题影响。`] : [])],
+        entity: { kind: 'source', id: health.sourceId },
+        sourceId: health.sourceId,
+        actions: cached
+            ? [
+                { id: 'refreshSource', label: '重新检查来源', description: '不会修改已安装内容' },
+                { id: 'continueWithCache', label: '继续使用缓存', description: '当前缓存仍可安全读取' },
+                { id: 'viewTechnical', label: '技术详情' },
+            ]
+            : [
+                { id: 'editSource', label: '编辑来源', description: '检查 URL、路径或 ref' },
+                { id: 'refreshSource', label: '稍后重试', description: '只重新检查来源' },
+                { id: 'viewTechnical', label: '技术详情' },
+            ],
+        technicalDetails: [{
+                code: cached ? 'catalogSourceDegraded' : 'catalogSourceUnavailable',
+                message: cached ? '远端检查失败；已验证缓存仍可用。' : '来源检查失败；没有可用缓存。',
+            }],
+    };
+}
+function targetIssues(payload) {
+    const issues = [];
+    const byPlacement = new Map();
+    for (const target of payload.targets) {
+        const key = `${target.pluginId}\0${target.platform}`;
+        byPlacement.set(key, [...(byPlacement.get(key) ?? []), target]);
+        if (target.state !== 'partial' && target.state !== 'error')
+            continue;
+        const codes = new Set(target.errors.map((error) => error.code));
+        const dependencyCodes = [
+            'dependencyMissing',
+            'dependencyNotReady',
+            'dependencyTargetUnsupported',
+            'dependencyStillRequired',
+            'dependencyGraphInvalid',
+        ];
+        const dependencyRoots = [...new Map(target.errors.flatMap((error) => {
+                if (!dependencyCodes.includes(error.code))
+                    return [];
+                const code = error.code;
+                const dependencyPluginId = dependencyPluginIdFromMessage(error.message);
+                return [[`${code}\0${dependencyPluginId ?? ''}`, {
+                            code,
+                            category: code,
+                            mergeEligible: false,
+                            error,
+                            dependencyPluginId,
+                        }]];
+            })).values()];
+        const roots = dependencyRoots.length > 0
+            ? dependencyRoots
+            : target.state === 'partial'
+                ? [{ code: 'partial', category: 'incompleteInstallation', mergeEligible: false }]
+                : codes.has('sourceMissing')
+                    ? [{ code: 'sourceMissing', category: 'sourceMissing', mergeEligible: false }]
+                    : codes.has('sourceChanged')
+                        ? [{ code: 'sourceChanged', category: 'sourceIdentityChanged', mergeEligible: false }]
+                        : [
+                            ...(codes.has('catalogSourceUnavailable')
+                                ? [{ code: 'catalogSourceUnavailable', category: 'sourceUnavailable', mergeEligible: true }]
+                                : []),
+                            ...(codes.has('bundleUnavailable')
+                                ? [{ code: 'bundleUnavailable', category: 'sourceUnavailable', mergeEligible: false }]
+                                : []),
+                            ...(!codes.has('catalogSourceUnavailable') && !codes.has('bundleUnavailable')
+                                ? [{ code: 'targetDiagnostic', category: 'diagnostic', mergeEligible: false }]
+                                : []),
+                        ];
+        for (const root of roots) {
+            const rootError = root.error ?? target.errors.find((error) => error.code === root.code);
+            const dependencyPluginId = root.dependencyPluginId
+                ?? (rootError ? dependencyPluginIdFromMessage(rootError.message) : undefined);
+            const dependencyCategory = root.category.startsWith('dependency');
+            const actions = root.category === 'dependencyMissing'
+                ? [
+                    ...(dependencyPluginId ? [{ id: 'installDependency', label: '补齐依赖插件',
+                            pluginId: dependencyPluginId, writeAction: 'install' }] : []),
+                    { id: 'viewDependencies', label: '查看依赖关系' },
+                    { id: 'viewTechnical', label: '技术详情' },
+                ]
+                : root.category === 'dependencyNotReady'
+                    ? [
+                        ...(dependencyPluginId ? [
+                            { id: 'viewDependencyIssue', label: '查看依赖插件问题', pluginId: dependencyPluginId },
+                            { id: 'reinstallDependency', label: '重新安装依赖插件',
+                                pluginId: dependencyPluginId, writeAction: 'reinstall' },
+                        ] : []),
+                        { id: 'viewDependencies', label: '查看依赖关系' },
+                        { id: 'viewTechnical', label: '技术详情' },
+                    ]
+                    : dependencyCategory
+                        ? [
+                            { id: 'viewDependencies', label: '查看依赖关系' },
+                            { id: 'viewTechnical', label: '技术详情' },
+                        ]
+                        : root.category === 'incompleteInstallation'
+                            ? [
+                                { id: 'reinstall', label: '重新安装', description: '保留插件设置，重新生成缺失内容' },
+                                { id: 'remove', label: '移除安装', description: '保留插件设置' },
+                                { id: 'viewTechnical', label: '技术详情' },
+                            ]
+                            : root.category === 'sourceMissing'
+                                ? [
+                                    { id: 'reAddSource', label: '重新添加同一来源', description: '保留来源 ID；来源类型和位置由你选择' },
+                                    { id: 'viewTechnical', label: '技术详情' },
+                                ]
+                                : root.category === 'sourceIdentityChanged'
+                                    ? [
+                                        { id: 'viewSourceChange', label: '查看来源变更', description: '不会自动覆盖现场状态' },
+                                        { id: 'viewTechnical', label: '技术详情' },
+                                    ]
+                                    : root.category === 'sourceUnavailable'
+                                        ? [
+                                            { id: 'editSource', label: '查看来源', description: root.code === 'bundleUnavailable' ? '检查这个插件包或稍后重试' : '修复来源配置或稍后重试' },
+                                            { id: 'viewTechnical', label: '技术详情' },
+                                        ]
+                                        : [{ id: 'viewTechnical', label: '技术详情' }, { id: 'retryLater', label: '稍后重试' }];
+            const issueId = `target:${target.pluginId}:${target.platform}:${target.scope}:${target.state}${roots.length > 1 ? `:${root.code}` : ''}${dependencyPluginId ? `:${dependencyPluginId}` : ''}`;
+            const bundleUnavailable = root.code === 'bundleUnavailable';
+            issues.push({
+                issueId,
+                category: root.category,
+                rootCode: root.code,
+                mergeEligible: root.mergeEligible,
+                title: `${target.pluginId} · ${target.platform === 'codex' ? 'Codex' : 'Claude Code'} · ${dependencyCategory ? {
+                    dependencyMissing: '缺少依赖',
+                    dependencyNotReady: '依赖安装不完整',
+                    dependencyTargetUnsupported: '依赖目标不兼容',
+                    dependencyStillRequired: '依赖仍被使用',
+                    dependencyGraphInvalid: '依赖关系无效',
+                }[root.category] : target.state === 'partial' ? '安装不完整' : bundleUnavailable ? '插件包不可用' : '检查失败'}`,
+                explanation: dependencyCategory
+                    ? dependencyPluginId
+                        ? `${dependencyPluginId} 导致当前依赖检查不能通过。`
+                        : '当前依赖检查不能安全通过。'
+                    : target.state === 'partial'
+                        ? '必要内容缺失，插件可能不能稳定运行。'
+                        : bundleUnavailable
+                            ? '当前来源中无法取得这个插件的可信 bundle。'
+                            : '当前目标不能安全分类为正常安装。',
+                impact: [bundleUnavailable
+                        ? '当前目标不能使用这个插件包；这不表示来源缓存整体不可用。'
+                        : '写操作前需要重新检查这个目标。'],
+                entity: { kind: 'plugin', id: target.pluginId },
+                pluginId: target.pluginId,
+                ...(dependencyPluginId ? { dependencyPluginId } : {}),
+                platform: target.platform,
+                scope: target.scope,
+                sourceId: target.sourceId,
+                sourceIdentity: target.sourceIdentity,
+                actions,
+                technicalDetails: target.errors.length > 0
+                    ? target.errors.filter((error) => root.code === 'targetDiagnostic'
+                        || root.code === 'partial'
+                        || error.code === root.code)
+                        .map((error) => ({ code: error.code, message: '状态检查报告了这个安全错误代码。' }))
+                    : [{ code: 'targetStateError', message: '目标状态异常。' }],
+            });
+        }
+    }
+    for (const targets of byPlacement.values()) {
+        const installed = targets.filter(isInstalledScopeEvidence);
+        if (new Set(installed.map((target) => target.scope)).size < 2)
+            continue;
+        const sample = installed[0];
+        issues.push({
+            issueId: `scope:${sample.pluginId}:${sample.platform}`,
+            category: 'scopeConflict',
+            title: `${sample.pluginId} · ${sample.platform === 'codex' ? 'Codex' : 'Claude Code'} · 安装位置冲突`,
+            explanation: '所有项目和当前项目同时发现了这个插件。',
+            impact: ['正常状态只能保留一个位置。'],
+            entity: { kind: 'plugin', id: sample.pluginId },
+            pluginId: sample.pluginId,
+            platform: sample.platform,
+            sourceId: sample.sourceId,
+            sourceIdentity: sample.sourceIdentity,
+            placements: installed.map((target) => target.scope).sort(compareText),
+            actions: [
+                { id: 'keepUserScope', label: '保留所有项目', description: '移除当前项目中的安装；设置保留' },
+                { id: 'keepProjectScope', label: '保留当前项目', description: '移除所有项目中的安装；设置保留' },
+                { id: 'viewTechnical', label: '查看两个位置的详情' },
+            ],
+            technicalDetails: [{ code: 'scopeConflict', message: '同一插件和平台存在两个安装位置。' }],
+        });
+    }
+    return issues;
+}
+function statusIssues(payload) {
+    const targetCodes = new Set(payload.targets.flatMap((target) => target.errors.map((error) => error.code)));
+    const issues = new Map();
+    for (const error of payload.errors) {
+        if (targetCodes.has(error.code) || issues.has(error.code))
+            continue;
+        const projection = error.code === 'legacyStateUnsupported'
+            ? {
+                title: '发现旧版状态',
+                explanation: '当前状态使用不受支持的旧格式。',
+                impact: '在迁移或清理旧状态前，部分操作不可用。',
+            }
+            : error.code === 'nativeStateUnreadable'
+                ? {
+                    title: '平台状态不可读',
+                    explanation: '当前不能安全读取平台状态。',
+                    impact: '部分安装状态可能不可用。',
+                }
+                : {
+                    title: '状态清单不可用',
+                    explanation: '当前不能完成状态清单检查。',
+                    impact: '部分安装状态可能不可用。',
+                };
+        issues.set(error.code, {
+            issueId: `status:${error.code}`,
+            category: error.code === 'legacyStateUnsupported' ? 'legacyState' : 'diagnostic',
+            title: projection.title,
+            explanation: projection.explanation,
+            impact: [projection.impact],
+            entity: { kind: 'source', id: payload.catalog.primarySourceId },
+            sourceId: payload.catalog.primarySourceId,
+            actions: error.code === 'legacyStateUnsupported'
+                ? [
+                    { id: 'manualMigration', label: '查看手动处理说明', description: '当前没有安全的自动迁移' },
+                    { id: 'retryLater', label: '稍后重新检查' },
+                ]
+                : [{ id: 'retryLater', label: '稍后重试' }, { id: 'viewTechnical', label: '技术详情' }],
+            technicalDetails: [{ code: error.code, message: projection.explanation }],
+        });
+    }
+    return [...issues.values()];
+}
+function configIssues(pluginSummaries) {
+    return pluginSummaries.flatMap((summary) => {
+        const sourceId = summary.pluginId.slice(0, summary.pluginId.indexOf('/'));
+        if (summary.configDiagnostic) {
+            return [{
+                    issueId: `config:${summary.pluginId}:read`,
+                    category: 'diagnostic',
+                    title: `${summary.displayName ?? summary.pluginName} · 设置状态不可读`,
+                    explanation: '当前不能安全读取这个插件的设置状态。',
+                    impact: ['其他插件仍可检查；当前插件的设置值不会显示。'],
+                    entity: { kind: 'plugin', id: summary.pluginId },
+                    pluginId: summary.pluginId,
+                    sourceId,
+                    actions: [
+                        { id: 'retryLater', label: '稍后重新检查' },
+                        { id: 'viewTechnical', label: '查看技术详情' },
+                    ],
+                    technicalDetails: [{ code: summary.configDiagnostic.code, message: summary.configDiagnostic.message }],
+                }];
+        }
+        if (!summary.configIssues?.length)
+            return [];
+        const types = new Set(summary.configIssues.map((issue) => issue.type));
+        const invalid = types.has('invalid-config');
+        const sources = new Set(summary.configIssues.map((issue) => issue.source));
+        const onlySource = sources.size === 1 ? [...sources][0] : undefined;
+        const configLayer = onlySource === 'user'
+            ? { scope: 'user', projectLayer: 'shared' }
+            : onlySource === 'project'
+                ? { scope: 'project', projectLayer: 'shared' }
+                : onlySource === 'projectLocal'
+                    ? { scope: 'project', projectLayer: 'local' }
+                    : undefined;
+        return [{
+                issueId: `config:${summary.pluginId}:${invalid ? 'invalid' : 'required'}`,
+                category: 'requiredConfigMissing',
+                title: `${summary.displayName ?? summary.pluginName} · ${invalid ? '设置值无效' : '缺少必填设置'}`,
+                explanation: invalid
+                    ? '已有设置值不符合当前字段规则。'
+                    : '插件缺少必填设置，写操作会在预检时被阻止。',
+                impact: [invalid ? '修正所列字段后才能稳定生成插件内容。' : '完成所列字段后才能稳定生成插件内容。'],
+                entity: { kind: 'plugin', id: summary.pluginId },
+                pluginId: summary.pluginId,
+                sourceId,
+                requiredFields: summary.configIssues.map(({ key, title, type, source }) => ({ key, title, type, source })),
+                ...(configLayer ? { configLayer } : {}),
+                actions: [
+                    { id: 'openConfig', label: invalid ? '修正设置' : '完成设置', description: configLayer ? '进入建议的设置层' : '选择个人或项目设置层' },
+                    { id: 'viewTechnical', label: '查看字段详情' },
+                ],
+                technicalDetails: summary.configIssues.map((entry) => ({
+                    code: entry.type,
+                    message: `${entry.title} · ${entry.source}`,
+                })),
+            }];
+    });
+}
+function enrichDependencyIssuePlacements(issues, overviews) {
+    const overviewById = new Map(overviews.map((overview) => [overview.pluginId, overview]));
+    return issues.map((issue) => {
+        if ((issue.category !== 'dependencyMissing' && issue.category !== 'dependencyNotReady')
+            || !issue.pluginId || !issue.dependencyPluginId || !issue.platform || !issue.scope)
+            return issue;
+        const dependency = overviewById.get(issue.pluginId)?.dependencies.find((candidate) => candidate.pluginId === issue.dependencyPluginId);
+        const references = (dependency?.placementReferences ?? []).filter((reference) => reference.consumer.pluginId === issue.pluginId
+            && reference.consumer.platform === issue.platform
+            && reference.consumer.scope === issue.scope
+            && (issue.scope === 'user' || reference.consumer.project === 'current'))
+            .sort((left, right) => [
+            left.dependency.pluginId,
+            left.dependency.platform,
+            left.dependency.scope,
+            left.dependency.project ?? '',
+        ].join('\0').localeCompare([
+            right.dependency.pluginId,
+            right.dependency.platform,
+            right.dependency.scope,
+            right.dependency.project ?? '',
+        ].join('\0'), 'en'));
+        const target = references[0]?.dependency;
+        if (!target) {
+            return {
+                ...issue,
+                actions: issue.actions.filter((action) => action.id !== 'installDependency' && action.id !== 'reinstallDependency'),
+            };
+        }
+        return {
+            ...issue,
+            dependencyPlatform: target.platform,
+            dependencyScope: target.scope,
+            dependencyProject: target.project,
+            actions: issue.actions.map((action) => action.id === 'installDependency' || action.id === 'reinstallDependency'
+                ? {
+                    ...action,
+                    platform: target.platform,
+                    scope: target.scope,
+                    project: target.project,
+                }
+                : action),
+        };
+    });
+}
+export function buildTuiViewModel(options) {
+    const dependencyById = new Map((options.dependencyOverviews ?? [])
+        .map((overview) => [overview.pluginId, overview]));
+    const summaryById = new Map(options.pluginSummaries.map((summary) => [summary.pluginId, summary]));
+    const targetsByPlugin = new Map();
+    for (const target of options.status.targets) {
+        targetsByPlugin.set(target.pluginId, [...(targetsByPlugin.get(target.pluginId) ?? []), target]);
+    }
+    const pluginIds = new Set([...summaryById.keys(), ...targetsByPlugin.keys()]);
+    const plugins = [...pluginIds].map((pluginId) => {
+        const summary = summaryById.get(pluginId);
+        const targets = targetsByPlugin.get(pluginId) ?? [];
+        const sourceId = targets[0]?.sourceId ?? pluginId.slice(0, pluginId.indexOf('/'));
+        const placements = ['codex', 'claude'].flatMap((platform) => {
+            const platformTargets = targets.filter((target) => target.platform === platform);
+            return platformTargets.length > 0 ? [projectPlatformPlacement(platform, platformTargets)] : [];
+        });
+        const attention = placements.some((placement) => placement.state === 'scopeConflict'
+            || (placement.state === 'installed' && placement.health !== 'ready'));
+        const installed = placements.some((placement) => placement.state !== 'notInstalled');
+        const unavailable = options.sourceHealth?.get(sourceId)?.state === 'unavailable';
+        return {
+            pluginId,
+            sourceId,
+            displayName: summary?.displayName ?? summary?.pluginName ?? targets[0]?.pluginName ?? pluginId,
+            description: summary?.description ?? '',
+            ...(summary?.version ?? targets[0]?.version
+                ? { version: summary?.version ?? targets[0]?.version }
+                : {}),
+            configFieldCount: summary?.configFieldCount
+                ?? Object.keys(summary?.configSchema ?? {}).length,
+            sourceLabel: sourceId,
+            supportedPlatforms: summary?.supportedTargets
+                ? ['codex', 'claude'].filter((platform) => summary.supportedTargets[platform].length > 0)
+                : placements.map((placement) => placement.platform),
+            installedPlacements: placements,
+            aggregateStatus: unavailable ? 'unavailable' : attention ? 'needsAttention' : installed ? 'installed' : 'available',
+            portableSkills: options.portablePluginIds?.includes(pluginId) ?? false,
+            ...(dependencyById.get(pluginId)
+                ? { dependencySummary: dependencyById.get(pluginId).summary }
+                : summary && (summary.dependencyTotalCount ?? 0) > 0
+                    ? { dependencySummary: {
+                            directCount: summary.dependencyDirectCount ?? 0,
+                            transitiveCount: Math.max(0, (summary.dependencyTotalCount ?? 0) - (summary.dependencyDirectCount ?? 0)),
+                            totalCount: summary.dependencyTotalCount ?? 0,
+                            readyCount: 0,
+                            missingCount: 0,
+                            issueCount: summary.dependencyIssueCount ?? 0,
+                        } }
+                    : {}),
+            technicalComponents: targets.flatMap((target) => target.components.map((component) => ({
+                platform: target.platform,
+                scope: target.scope,
+                key: component.key,
+                state: component.state,
+                ...(component.error ? { errorCode: component.error.code } : {}),
+            }))),
+        };
+    }).sort((left, right) => compareText(left.displayName, right.displayName)
+        || compareText(left.sourceId, right.sourceId));
+    const sourceTabs = options.status.catalog.sources.map((source) => ({
+        id: source.id,
+        label: source.id,
+        count: plugins.filter((plugin) => plugin.sourceId === source.id).length,
+        primary: source.primary,
+        state: sourceState(source, options.sourceHealth?.get(source.id)),
+    }));
+    const sourceRootIds = new Set([...(options.sourceHealth?.values() ?? [])]
+        .filter((health) => health.state === 'cache' || health.state === 'degraded' || health.state === 'unavailable')
+        .map((health) => health.sourceId));
+    const allTargetIssues = targetIssues(options.status);
+    const targetImpactCounts = new Map();
+    for (const issue of allTargetIssues) {
+        if (!issue.mergeEligible || !issue.sourceId || !sourceRootIds.has(issue.sourceId))
+            continue;
+        targetImpactCounts.set(issue.sourceId, (targetImpactCounts.get(issue.sourceId) ?? 0) + 1);
+    }
+    const issues = enrichDependencyIssuePlacements([
+        ...allTargetIssues.filter((issue) => !issue.mergeEligible
+            || !issue.sourceId || !sourceRootIds.has(issue.sourceId)),
+        ...statusIssues(options.status),
+        ...configIssues(options.pluginSummaries),
+        ...[...(options.sourceHealth?.values() ?? [])].flatMap((health) => sourceIssue(health, targetImpactCounts.get(health.sourceId) ?? 0) ?? []),
+    ], options.dependencyOverviews ?? []);
+    return {
+        plugins,
+        sourceTabs,
+        sourceDetails: (options.sourceDetails ?? []).map((detail) => ({
+            ...detail,
+            pluginCount: plugins.filter((plugin) => plugin.sourceId === detail.id).length,
+        })),
+        issues,
+        dependencyOverviews: options.dependencyOverviews ?? [],
+        home: {
+            availablePlugins: plugins.filter((plugin) => plugin.aggregateStatus === 'available').length,
+            installedPlugins: plugins.filter(hasInstalledPlacement).length,
+            issueCount: issues.length,
+            sourceCount: sourceTabs.length,
+            cachedSourceCount: sourceTabs.filter((source) => source.state === 'cache').length,
+            unavailableSourceCount: sourceTabs.filter((source) => source.state === 'error').length,
+        },
+    };
+}
+function displayConfigValue(options) {
+    if (!options.configured)
+        return options.inherited ? '继承' : '未设置';
+    if (options.privateValue)
+        return '已设置';
+    if (typeof options.value === 'string')
+        return options.value;
+    if (options.value === undefined || options.value === null)
+        return '已设置';
+    return String(options.value);
+}
+function configSourceLabel(source) {
+    if (!source)
+        return '未设置';
+    return {
+        default: '默认值',
+        user: '个人默认',
+        project: '当前项目',
+        local: '当前项目（仅本机）',
+    }[source];
+}
+export function buildConfigGroups(options) {
+    const entryByKey = new Map(options.read.fields.map((field) => [field.key, field]));
+    const effectivePage = options.read.scope === 'effective';
+    const fieldModel = (key) => {
+        const schema = options.schema.schema[key];
+        const entry = entryByKey.get(key);
+        const presentation = options.schema.presentation?.fields?.[key];
+        const inherited = effectivePage
+            ? entry?.sourceLayer === undefined || entry?.sourceLayer === null
+            : entry?.storedSourceLayer === undefined;
+        const configured = effectivePage
+            ? entry?.valueState === 'configured' || entry?.valueState === 'default'
+            : entry?.storedSourceLayer !== undefined;
+        const privateValue = schema.sensitive === true || schema.type === 'file' || schema.type === 'directory';
+        const selectedValue = effectivePage ? entry?.effectiveValue : entry?.storedValue;
+        return {
+            key,
+            title: schema.title ?? key,
+            ...(schema.description ? { description: schema.description } : {}),
+            type: schema.type,
+            displayValue: displayConfigValue({
+                privateValue,
+                inherited,
+                configured,
+                value: selectedValue,
+            }),
+            required: schema.required === true,
+            sensitive: schema.sensitive === true,
+            dirty: options.dirtyKeys?.has(key) === true,
+            inherited,
+            configured,
+            sourceLabel: effectivePage
+                ? configSourceLabel(entry?.sourceLayer ?? null)
+                : configured ? '本层已设置' : '继承',
+            ...(!privateValue && selectedValue !== undefined
+                ? { value: selectedValue }
+                : {}),
+            ...(!privateValue && schema.default !== undefined ? { defaultValue: schema.default } : {}),
+            ...(schema.values ? { enumValues: [...schema.values] } : {}),
+            ...(presentation?.valueLabels ? { valueLabels: { ...presentation.valueLabels } } : {}),
+            ...(presentation?.recommendedValue !== undefined
+                ? { recommendedValue: presentation.recommendedValue }
+                : {}),
+            ...(presentation?.placeholder ? { placeholder: presentation.placeholder } : {}),
+            ...(presentation?.unit ? { unit: presentation.unit } : {}),
+            ...(schema.min !== undefined ? { min: schema.min } : {}),
+            ...(schema.max !== undefined ? { max: schema.max } : {}),
+            advanced: presentation?.advanced === true,
+        };
+    };
+    const assigned = new Set();
+    const groups = (options.schema.presentation?.groups ?? []).map((group) => {
+        group.fields.forEach((key) => assigned.add(key));
+        return {
+            id: group.id,
+            title: group.title,
+            ...(group.description ? { description: group.description } : {}),
+            advanced: group.advanced === true,
+            fields: group.fields.map(fieldModel),
+        };
+    });
+    const syntheticGroupId = (preferred) => {
+        const existing = new Set(groups.map((group) => group.id));
+        let id = preferred;
+        let suffix = 2;
+        while (existing.has(id)) {
+            id = `${preferred}-${suffix}`;
+            suffix += 1;
+        }
+        return id;
+    };
+    const remaining = Object.keys(options.schema.schema).filter((key) => !assigned.has(key));
+    if (!options.schema.presentation) {
+        groups.push({
+            id: 'general',
+            title: '插件设置',
+            advanced: false,
+            fields: Object.keys(options.schema.schema).map(fieldModel),
+        });
+    }
+    else {
+        const ordinary = remaining.filter((key) => options.schema.presentation?.fields?.[key]?.advanced !== true);
+        const advanced = remaining.filter((key) => options.schema.presentation?.fields?.[key]?.advanced === true);
+        if (ordinary.length > 0) {
+            groups.push({
+                id: syntheticGroupId('general'),
+                title: groups.length === 0 ? '插件设置' : '其他设置',
+                advanced: false,
+                fields: ordinary.map(fieldModel),
+            });
+        }
+        if (advanced.length > 0) {
+            groups.push({
+                id: syntheticGroupId('advanced'),
+                title: '高级设置',
+                advanced: true,
+                fields: advanced.map(fieldModel),
+            });
+        }
+    }
+    return groups;
+}
+export function buildConfigPage(options) {
+    const privateFields = new Set(Object.entries(options.schema.schema)
+        .filter(([, field]) => field.sensitive === true || field.type === 'file' || field.type === 'directory')
+        .map(([key]) => key));
+    const presets = (options.schema.presentation?.presets ?? []).map((preset) => {
+        const privateFieldTitles = Object.keys(preset.values)
+            .filter((key) => privateFields.has(key))
+            .map((key) => options.schema.schema[key]?.title ?? key);
+        return {
+            id: preset.id,
+            title: preset.title,
+            ...(preset.description ? { description: preset.description } : {}),
+            values: Object.fromEntries(Object.entries(preset.values)
+                .filter(([key]) => !privateFields.has(key))),
+            ...(privateFieldTitles.length > 0 ? { privateFieldTitles } : {}),
+        };
+    });
+    return {
+        pluginId: options.pluginId,
+        layer: { scope: options.read.scope, projectLayer: options.read.projectLayer },
+        groups: buildConfigGroups(options),
+        presets,
+        storedCount: options.read.fields.filter((field) => field.storedSourceLayer !== undefined).length,
+    };
+}
+//# sourceMappingURL=model.js.map