@fses/workbench-app 0.2.0 → 0.2.1

package/node_modules/@fses/workbench-card/dist/types/canvas.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @fileoverview 工作台画布基础类型 - 暴露组件库需要的卡片尺寸和画布交互契约。
+ * @author seadon
+ * @created 2026-05-20
+ */
+import type { MaterializedBlock } from './block';
+export type CardSizePreset = 'small' | 'medium' | 'componentTall' | 'large' | 'screen';
+export type WorkbenchCardDensity = 'thumbnail' | 'compact' | 'standard' | 'expanded';
+export interface WorkbenchLayoutChangeItem {
+    i: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface WorkbenchCanvasNotice {
+    id: string;
+    title: string;
+    detail: string;
+    tone?: 'info' | 'warning';
+}
+export interface WorkbenchBlockActionPayload {
+    block: MaterializedBlock;
+    overrideCapabilityId?: string;
+}

package/node_modules/@fses/workbench-card/dist/types/echartsProtocol.d.ts

@@ -0,0 +1,445 @@
+/**
+ * @fileoverview ECharts 协议类型 - 定义卡片协议配置、数据载荷和转换器接口。
+ * @author seadon
+ * @created 2026-05-20
+ */
+import type { EChartsOption } from 'echarts';
+/**
+ * Supported renderer types for card payloads.
+ * Extensible via `string` to allow future renderers without breaking changes.
+ */
+export type RendererType = 'echarts' | 'table' | 'metric' | 'richtext' | 'iframe' | (string & {});
+/**
+ * Top-level card payload delivered by the backend pipeline.
+ * Each card carries a renderer type discriminator so the frontend can route
+ * it to the correct renderer component.
+ */
+export interface CardPayload {
+    /** Discriminator that determines which renderer component handles this card */
+    rendererType: RendererType;
+    /** Unique identifier for the card instance */
+    cardId: string;
+    /** Primary display title */
+    title: string;
+    /** Optional secondary description */
+    subtitle?: string;
+    /** Renderer-specific configuration (e.g. ProtocolConfigPayload for echarts) */
+    configPayload: unknown;
+    /** Renderer-specific data (e.g. ProtocolDataPayload for echarts) */
+    dataPayload?: unknown;
+    /** Optional binding ID linking this card to a data source */
+    dataBindingId?: string;
+}
+/**
+ * The 13 canonical protocol types that describe how chart data is structured.
+ * Each type implies a specific data shape and converter strategy.
+ */
+export type ProtocolType = 'series' | 'table' | 'tuple' | 'tree' | 'network' | 'geo' | 'scene3D' | 'timeline' | 'transition' | 'graphic' | 'layout' | 'composite' | 'configOnly';
+/**
+ * Chart family classification used to group charts by coordinate system.
+ */
+export type ChartFamily = 'cartesian' | 'radial' | 'tree' | 'network' | 'geo' | 'gl' | 'free';
+/**
+ * Describes a single series definition within a chart configuration.
+ * Maps one-to-one with ECharts series entries in the generated option.
+ */
+export interface SeriesDef {
+    /** Unique series identifier */
+    id: string;
+    /** ECharts series type (e.g. 'bar', 'line', 'pie') */
+    type: string;
+    /** Optional reference to a dataset the series draws from */
+    datasetId?: string;
+}
+/**
+ * Static configuration payload that describes how to build the ECharts option.
+ * This is the "skeleton" of the chart — it defines structure but not the data.
+ */
+export interface ProtocolConfigPayload {
+    /** Protocol version for forward compatibility */
+    version: '1.0';
+    /** Discriminator indicating the protocol structure type */
+    protocolType: ProtocolType;
+    /** Unique identifier for the chart this config belongs to */
+    chartId: string;
+    /** Chart metadata */
+    chart: {
+        /** Chart identifier (may differ from chartId when chart is templated) */
+        id: string;
+        /** Human-readable chart title */
+        title: string;
+        /** Chart coordinate family classification */
+        family: ChartFamily;
+        /** Rendering engine */
+        renderer: 'canvas' | 'svg';
+    };
+    /** Series definitions describing each data series in the chart */
+    series: SeriesDef[];
+    /** Presentation configuration for visual elements */
+    presentation: {
+        /** ECharts theme name or theme object */
+        theme?: string | Record<string, unknown>;
+        /** Tooltip configuration */
+        tooltip?: Record<string, unknown>;
+        /** Legend configuration */
+        legend?: Record<string, unknown>;
+        /** Animation configuration */
+        animation?: Record<string, unknown>;
+    };
+    /** Extraction status metadata */
+    extraction?: {
+        /** Current extraction status (e.g. 'complete', 'partial') */
+        status: string;
+    };
+    /** Official ECharts example comparison for reference */
+    officialComparison?: {
+        /** URL to the ECharts editor with the original example */
+        editorUrl: string;
+        /** URL to the source code of the original example */
+        sourceUrl: string;
+    };
+    /** Source replay configuration for reproducing the chart from original examples */
+    officialSourceReplay?: {
+        /** Whether source replay is enabled */
+        enabled: boolean;
+        /** Relative path to the source file */
+        sourceRelativePath: string;
+        /** Root path of the source repository */
+        rootPath: string;
+        /** CDN path for asset resolution */
+        cdnPath: string;
+        /** External dependency requirements */
+        requires: {
+            echartsGl?: boolean;
+            jquery?: boolean;
+            d3?: boolean;
+            ecStat?: boolean;
+            datGui?: boolean;
+        };
+    };
+    /** Arbitrary ECharts option overrides merged on top of the generated option */
+    optionPatch?: Record<string, unknown>;
+}
+/**
+ * Base fields shared by all protocol data payloads.
+ * Each concrete payload re-declares `protocolType` as a string literal
+ * so TypeScript can discriminate between them in the union type.
+ */
+interface ProtocolDataBase {
+    /** Protocol version for forward compatibility */
+    version: '1.0';
+    /** Unique identifier for the chart this data belongs to */
+    chartId: string;
+    /** Optional parameters passed alongside the data */
+    params?: Record<string, unknown>;
+    /** Reload policy controlling how data updates are handled */
+    reloadPolicy: {
+        /** Reload mode (e.g. 'replace', 'append', 'merge') */
+        mode: string;
+        /** Whether this data type supports refreshing without rebuilding the option */
+        supportsDataOnlyReload: boolean;
+    };
+    /** Extraction metadata */
+    extraction?: {
+        status: string;
+    };
+}
+/**
+ * Series protocol data — standard cartesian / radial chart data with
+ * categories on one axis and one or more numeric series.
+ */
+export interface SeriesDataPayload extends ProtocolDataBase {
+    protocolType: 'series';
+    /** Category labels for cartesian x-axis, or radar indicators for radial charts */
+    categories: {
+        xAxis?: string[];
+        indicators?: Array<{
+            name: string;
+            max?: number;
+        }>;
+    };
+    /** Array of data series, each with numeric values */
+    series: Array<{
+        /** Series identifier matching SeriesDef.id */
+        id: string;
+        /** Series display name */
+        name: string;
+        /** Hint for the preferred ECharts series type */
+        typeHint?: string;
+        /** Numeric data values, one per category */
+        data: number[];
+    }>;
+}
+/**
+ * Table protocol data — tabular data organized by datasets with dimensions.
+ */
+export interface TableDataPayload extends ProtocolDataBase {
+    protocolType: 'table';
+    /** Array of tabular datasets */
+    datasets: Array<{
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'table';
+        /** Column dimension names */
+        dimensions?: string[];
+        /** Raw data rows (array of arrays) */
+        source: unknown[][];
+        /** Rows as key-value records (optional alternative to source) */
+        rows?: Record<string, unknown>[];
+    }>;
+}
+/**
+ * Tuple protocol data — combines categories with tuple-structured rows.
+ */
+export interface TupleDataPayload extends ProtocolDataBase {
+    protocolType: 'tuple';
+    /** Single tuple dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'tuple';
+        /** Kind of tuple encoding */
+        tupleKind: string;
+        /** Column dimension names */
+        dimensions: string[];
+        /** Optional category labels for tuple axes */
+        categories?: {
+            xAxis: string[];
+            yAxis?: string[];
+        };
+        /** Data rows as arrays */
+        rows: unknown[][];
+    };
+}
+/**
+ * Hierarchical tree node used in TreeDataPayload.
+ */
+export interface TreeNode {
+    /** Node display name */
+    name: string;
+    /** Optional numeric value for leaf nodes */
+    value?: number;
+    /** Whether the node starts collapsed */
+    collapsed?: boolean;
+    /** Child nodes */
+    children?: TreeNode[];
+}
+/**
+ * Tree protocol data — hierarchical data with nested nodes.
+ */
+export interface TreeDataPayload extends ProtocolDataBase {
+    protocolType: 'tree';
+    /** Single tree dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'tree';
+        /** Root nodes of the tree (multiple roots supported) */
+        roots: TreeNode[];
+    };
+}
+/**
+ * Network node used in NetworkDataPayload.
+ */
+export interface NetworkNode {
+    /** Node unique name / identifier */
+    name: string;
+    /** Optional numeric value for sizing */
+    value?: number;
+    /** Optional category index for grouping */
+    category?: number;
+    /** Optional symbol size */
+    symbolSize?: number;
+    /** Additional node properties */
+    [key: string]: unknown;
+}
+/**
+ * Network link (edge) used in NetworkDataPayload.
+ */
+export interface NetworkLink {
+    /** Source node name */
+    source: string;
+    /** Target node name */
+    target: string;
+    /** Optional link value for width weighting */
+    value?: number;
+    /** Additional link properties */
+    [key: string]: unknown;
+}
+/**
+ * Network protocol data — graph / relationship data with nodes and links.
+ */
+export interface NetworkDataPayload extends ProtocolDataBase {
+    protocolType: 'network';
+    /** Single network dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'network';
+        /** Graph nodes */
+        nodes: NetworkNode[];
+        /** Graph edges / links */
+        links: NetworkLink[];
+        /** Optional category labels for node grouping */
+        categories?: Array<{
+            name: string;
+        }>;
+    };
+}
+/**
+ * Geo protocol data — geographic data with regions, points, and lines.
+ */
+export interface GeoDataPayload extends ProtocolDataBase {
+    protocolType: 'geo';
+    /** Single geo dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'geo';
+        /** ECharts map name (e.g. 'china', 'world') */
+        mapName?: string;
+        /** Point data for scatter overlay */
+        points?: unknown[];
+        /** Line data for connection overlay */
+        lines?: unknown[];
+        /** Region data with name-value pairs */
+        regions: Array<{
+            /** Region name matching map geography */
+            name: string;
+            /** Region numeric value for coloring */
+            value: number;
+        }>;
+    };
+}
+/**
+ * 3D scene protocol data — data for echarts-gl 3D visualizations.
+ */
+export interface Scene3DDataPayload extends ProtocolDataBase {
+    protocolType: 'scene3D';
+    /** Single 3D scene dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'scene3d';
+        /** Additional 3D-specific data properties */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Timeline protocol data — data with temporal ordering.
+ */
+export interface TimelineDataPayload extends ProtocolDataBase {
+    protocolType: 'timeline';
+    /** Single timeline dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'timeline';
+        /** Additional timeline-specific data properties */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Transition protocol data — data for animated state transitions.
+ */
+export interface TransitionDataPayload extends ProtocolDataBase {
+    protocolType: 'transition';
+    /** Single transition dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'transition';
+        /** Additional transition-specific data properties */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Graphic protocol data — custom graphic elements.
+ */
+export interface GraphicDataPayload extends ProtocolDataBase {
+    protocolType: 'graphic';
+    /** Single graphic dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'graphic';
+        /** Custom graphic element descriptors */
+        elements: unknown[];
+    };
+}
+/**
+ * Layout protocol data — grid / dashboard layout descriptors.
+ */
+export interface LayoutDataPayload extends ProtocolDataBase {
+    protocolType: 'layout';
+    /** Single layout dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'layout';
+        /** Grid layout descriptors */
+        grids: unknown[];
+    };
+}
+/**
+ * Composite protocol data — mixed / multi-chart composites.
+ */
+export interface CompositeDataPayload extends ProtocolDataBase {
+    protocolType: 'composite';
+    /** Single composite dataset */
+    dataset: {
+        /** Dataset identifier */
+        id: string;
+        /** Data shape discriminator */
+        shape: 'composite';
+        /** Additional composite-specific data properties */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Config-only protocol data — charts that carry no external data
+ * (all data is embedded in the config option).
+ */
+export interface ConfigOnlyDataPayload extends ProtocolDataBase {
+    protocolType: 'configOnly';
+    /** Placeholder dataset with no actual data */
+    dataset: {
+        /** Shape discriminator indicating no data payload */
+        shape: 'none';
+    };
+}
+/**
+ * Discriminated union of all 13 protocol data payloads.
+ * Use `payload.protocolType` to narrow to the specific type.
+ */
+export type ProtocolDataPayload = SeriesDataPayload | TableDataPayload | TupleDataPayload | TreeDataPayload | NetworkDataPayload | GeoDataPayload | Scene3DDataPayload | TimelineDataPayload | TransitionDataPayload | GraphicDataPayload | LayoutDataPayload | CompositeDataPayload | ConfigOnlyDataPayload;
+/**
+ * Converter interface that transforms protocol payloads into ECharts options.
+ * Each protocol type should have its own implementation of this interface.
+ */
+export interface ProtocolConverter {
+    /**
+     * Build a complete ECharts option from the config payload.
+     * @param config - The protocol configuration describing chart structure
+     * @returns A fully-formed ECharts option ready for rendering
+     */
+    buildOption(config: ProtocolConfigPayload): EChartsOption;
+    /**
+     * Merge data payload into an existing ECharts option without rebuilding it.
+     * @param option - The existing ECharts option to update
+     * @param data - The protocol data payload to merge
+     * @returns The updated ECharts option
+     */
+    mergeData(option: EChartsOption, data: ProtocolDataPayload): EChartsOption;
+}
+export {};

package/node_modules/@fses/workbench-card/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview workbench-card 类型总入口 - 汇总 block、canvas、registry、runtime 和 ECharts 协议类型。
+ * @author seadon
+ * @created 2026-05-20
+ */
+export * from './block';
+export * from './canvas';
+export * from './registry';
+export * from './runtime';
+export * from './echartsProtocol';

package/node_modules/@fses/workbench-card/dist/types/registry.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview 工作台卡片注册表类型入口 - 复用 registry 模块公开的卡片能力类型。
+ * @author seadon
+ * @created 2026-05-20
+ */
+export type { CardCategoryDefinition, CardCategoryStatus, CardRegistryEntry, } from '../registry/cardRegistry';
+export type { CompositeCardDataContract, CompositeCardLayoutRule, CompositeCardPattern, CompositeCardPatternId, CompositeCardQueryContract, } from '../registry/compositeCardPatterns';

package/node_modules/@fses/workbench-card/dist/types/runtime.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview 工作台组件运行时类型 - 描述宿主应用注入给 UI 组件库的回调和状态。
+ * @author seadon
+ * @created 2026-05-20
+ */
+import type { MaterializedBlock, RoleId } from './block';
+export type WorkbenchDataBindingStatus = 'idle' | 'loading' | 'running' | 'ready' | 'empty' | 'error';
+export interface WorkbenchBindingStatusSnapshot {
+    bindingId: string;
+    status: WorkbenchDataBindingStatus;
+    message?: string;
+    updatedAt?: number;
+}
+export type WorkbenchBindingStatusMap = Record<string, WorkbenchBindingStatusSnapshot>;
+export interface WorkbenchRenderContext {
+    roleId?: RoleId | string;
+    userId?: string;
+    readonly?: boolean;
+    configModeActive?: boolean;
+}
+export interface WorkbenchInteractionHandlers {
+    focusBlock?: (blockId: string) => void;
+    retryDataBindingCandidate?: (block: MaterializedBlock) => void;
+    replaceManualPlaceholder?: (payload: {
+        block: MaterializedBlock;
+        overrideCapabilityId?: string;
+    }) => void;
+    onRenderError?: (payload: {
+        blockId?: string;
+        rendererKey?: string;
+        message: string;
+        cause?: unknown;
+    }) => void;
+}

package/node_modules/@fses/workbench-card/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@fses/workbench-card",
+  "version": "0.3.0",
+  "private": false,
+  "type": "module",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/fses-workbench-card.umd.cjs",
+  "module": "./dist/fses-workbench-card.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "development": "./src/index.ts",
+      "import": "./dist/fses-workbench-card.js",
+      "require": "./dist/fses-workbench-card.umd.cjs"
+    },
+    "./renderers": {
+      "types": "./dist/renderers/index.d.ts",
+      "development": "./src/renderers/index.ts",
+      "import": "./dist/fses-workbench-card-renderers.js"
+    },
+    "./chart": {
+      "types": "./dist/chart/index.d.ts",
+      "development": "./src/chart/index.ts",
+      "import": "./dist/fses-workbench-card.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "development": "./src/types/index.ts",
+      "import": "./dist/fses-workbench-card.js"
+    },
+    "./registry": {
+      "types": "./dist/registry/index.d.ts",
+      "development": "./src/registry/index.ts",
+      "import": "./dist/fses-workbench-card.js"
+    },
+    "./echarts-protocol": {
+      "types": "./dist/renderers/chart/echarts-protocol/index.d.ts",
+      "development": "./src/renderers/chart/echarts-protocol/index.ts",
+      "import": "./dist/fses-workbench-card-echarts-protocol.js"
+    },
+    "./styles.css": "./dist/style.css",
+    "./dist/style.css": "./dist/style.css"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@ant-design/icons-vue": "^7.0.1",
+    "ant-design-vue": "^4.2.6",
+    "echarts": "^5.4.0 || ^6.0.0",
+    "echarts-gl": "^2.0.9",
+    "lucide-vue-next": "^0.577.0 || ^1.0.0",
+    "vue": "^3.5.32"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@types/jest": "29.5.14",
+    "@types/node": "20.17.30",
+    "@vitejs/plugin-vue": "^5.2.4",
+    "@vue/test-utils": "^2.4.6",
+    "@vue/vue3-jest": "^29.2.6",
+    "babel-jest": "^29.7.0",
+    "echarts": "^6.0.0",
+    "echarts-gl": "^2.0.9",
+    "jest": "29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "ts-jest": "29.4.9",
+    "typescript": "^5.4.5",
+    "vite": "^5.4.19",
+    "vue-tsc": "^2.2.10"
+  },
+  "scripts": {
+    "stub": "node ./scripts/clean-tsbuildinfo.mjs && vue-tsc --emitDeclarationOnly",
+    "build": "node ./scripts/clean-tsbuildinfo.mjs && vite build && vite build --config vite.config.renderers.ts --emptyOutDir false && vite build --config vite.config.echarts-protocol.ts --emptyOutDir false && vue-tsc --emitDeclarationOnly",
+    "test": "jest --config test/jest.config.cjs --runInBand",
+    "verify:exports": "node ../../scripts/verify-package-exports.mjs ."
+  }
+}

package/node_modules/@fses/workbench-card/src/chart/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview workbench-card chart entry - exports framework-free chart registry and option helpers.
+ * @author seadon
+ * @created 2026-05-20
+ */
+export * from '../renderers/chart/chartRendererRegistry';
+export * from '../renderers/chart/echartsRuntimeInteractions';
+export * from '../renderers/chart/echartsTitle';

package/node_modules/@fses/workbench-card/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview workbench-card public entry - exports reusable workbench card components, types, registry helpers, and styles.
+ * @author seadon
+ * @created 2026-05-20
+ */
+import './styles/workbench-card.css';
+
+export * from './registry';
+export * from './chart';
+export * from './shell/workbenchVisualShell';
+export * from './types';
+
+export const WORKBENCH_CARD_PACKAGE_NAME = '@fses/workbench-card';