dsh-crwu-workbench 0.0.10

package/skills/dws/dingtalk-misc/scripts/yida_report_charts.py

@@ -0,0 +1,1434 @@
+"""
+宜搭报表图表组件构造 — 按 chart.type 分发，产出 component dict + cube 查询模型。
+
+支持 9 种图表: bar / line / pie / funnel / table / indicator / gauge / combo / pivot
+
+dataSetModelMap 结构严格匹配宜搭报表引擎格式：
+  - 外层 key: chartData (bar/line/pie/funnel/gauge) / table / youshuData (indicator)
+              / dataSetName (combo/pivot)
+  - 内层: dataViewQueryModel{cubeCode, fieldDefinitionList, fieldList, cubeTenantId}
+        + 外层 fieldList (完整字段对象) + xField/yField 等角色字段
+"""
+from __future__ import annotations
+
+import math
+from typing import Any, Optional
+
+from yida_schema_common import (
+    i18n,
+    next_node_id,
+    generate_field_id,
+)
+
+# ---------------------------------------------------------------------------
+# 图表类型 → componentName 映射
+# ---------------------------------------------------------------------------
+
+CHART_TYPE_MAP: dict[str, str] = {
+    "bar": "YoushuGroupedBarChart",
+    "line": "YoushuLineChart",
+    "pie": "YoushuPieChart",
+    "funnel": "YoushuFunnelChart",
+    "table": "YoushuTable",
+    "indicator": "YoushuSimpleIndicatorCard",
+    "gauge": "YoushuGauge",
+    "combo": "YoushuComboChart",
+    "pivot": "YoushuCrossPivotTable",
+}
+
+def _compute_dynamic_layout(chart_type: str, chart: dict[str, Any]) -> dict[str, Any]:
+    """根据图表内容动态计算布局尺寸。"""
+    if chart_type == "table":
+        page_size = chart.get("pageSize", 20)
+        h = max(16, min(40, round(page_size * 0.9) + 6))
+        return {"w": 6, "h": h, "minH": h, "maxH": h, "resizeHandles": ["w", "e"]}
+
+    if chart_type == "indicator":
+        kpi_count = len(chart.get("kpi", []))
+        col = min(kpi_count, 4) or 1
+        rows = math.ceil(kpi_count / col)
+        h = max(11, 8 + rows * 5)
+        w = min(2 * min(kpi_count, 3), 6)
+        return {"w": w, "h": h, "minH": h, "maxH": h, "resizeHandles": ["w", "e"]}
+
+    if chart_type in ("bar", "line"):
+        y_raw = chart.get("yField", "")
+        y_count = len(y_raw) if isinstance(y_raw, list) else 1
+        h = 22 if y_count <= 3 else min(30, 22 + (y_count - 3) * 2)
+        return {"w": 3, "h": h}
+
+    if chart_type == "gauge":
+        return {"w": 2, "h": 18}
+
+    if chart_type == "combo":
+        return {"w": 6, "h": 22}
+
+    if chart_type == "pivot":
+        return {"w": 6, "h": 30}
+
+    return {"w": 3, "h": 22}
+
+_VALUE_SUFFIX_PREFIXES = ("selectField_", "radioField_", "checkboxField_", "multiSelectField_", "employeeField_")
+
+_CUBE_LABEL_SUFFIX: dict[str, str] = {
+    "selectField_": "_值",
+    "radioField_": "_值",
+    "checkboxField_": "_值",
+    "multiSelectField_": "_值",
+    "employeeField_": "_名称",
+    "departmentSelectField_": "_名称",
+}
+
+_DS_KEY_CHART = "chartData"
+_DS_KEY_TABLE = "table"
+_DS_KEY_INDICATOR = "youshuData"
+_DS_KEY_DATASET = "dataSetName"
+
+_TIME_GRAN_ID_SUFFIX: dict[str, str] = {
+    "YEAR": "1", "QUARTER": "2", "MONTH": "3",
+    "WEEK": "4", "DAY": "5", "HOUR": "6",
+}
+_TIME_GRAN_FORMAT: dict[str, str] = {
+    "YEAR": "yyyy", "QUARTER": "yyyy-Q", "MONTH": "yyyy-MM",
+    "WEEK": "yyyy-w", "DAY": "yyyy-MM-dd", "HOUR": "yyyy-MM-dd HH",
+}
+
+_AGGREGATE_TYPES = frozenset({"COUNT", "SUM", "AVG", "MAX", "MIN", "COUNT_DISTINCT"})
+
+
+# ---------------------------------------------------------------------------
+# 公共工具
+# ---------------------------------------------------------------------------
+
+
+def normalize_cube_code(code: str) -> str:
+    """FORM-E604838A-3121-43D1-... → FORM_E604838A312143D1..."""
+    if code.startswith(("FORM-", "FORM_")):
+        return "FORM_" + code[5:].replace("-", "")
+    return code.replace("-", "_")
+
+
+_STRIP_SUFFIXES = ("_id", "_date")
+
+
+def normalize_field_code(field_code: str) -> str:
+    fc = field_code
+    for sfx in _STRIP_SUFFIXES:
+        if fc.endswith(sfx):
+            fc = fc[:-len(sfx)]
+            break
+    if any(fc.startswith(p) for p in _VALUE_SUFFIX_PREFIXES):
+        if not fc.endswith("_value"):
+            return fc + "_value"
+    return fc
+
+
+def _apply_cube_label_suffix(field_code: str, text: str) -> str:
+    """fieldCode 带 _value 后缀时，同步给显示标签追加中文后缀。
+
+    cube 元数据中 selectField_xxx_value 显示名为 "原标签_值"，
+    employeeField_xxx_value 显示名为 "原标签_名称"。
+    不追加会导致引擎报"找不到配置"。
+    """
+    if not field_code.endswith("_value"):
+        return text
+    base = field_code[:-6]
+    for prefix, suffix in _CUBE_LABEL_SUFFIX.items():
+        if base.startswith(prefix):
+            if not text.endswith(suffix):
+                return text + suffix
+            return text
+    return text
+
+
+def _derive_label(field_code: str) -> str:
+    """从 fieldCode 推导可读标签：去前缀、去 _value 后缀。"""
+    fc = field_code
+    for p in _VALUE_SUFFIX_PREFIXES:
+        if fc.startswith(p):
+            fc = fc[len(p):]
+            break
+    else:
+        for prefix in ("textField_", "numberField_", "dateField_", "textareaField_",
+                        "countrySelectField_", "addressField_", "attachmentField_",
+                        "imageField_", "departmentSelectField_", "tableField_",
+                        "associationFormField_", "serialNumberField_", "rateField_",
+                        "cascadeDateField_"):
+            if fc.startswith(prefix):
+                fc = fc[len(prefix):]
+                break
+    if fc.endswith("_value"):
+        fc = fc[:-6]
+    return fc or field_code
+
+
+def _infer_data_type(field_code: str) -> str:
+    if field_code.startswith("numberField_"):
+        return "NUMBER"
+    if field_code.startswith("dateField_"):
+        return "DATE"
+    if field_code.startswith(("employeeField_", "departmentSelectField_")):
+        return "STRING" if field_code.endswith("_value") else "ARRAY"
+    return "STRING"
+
+
+_ARRAY_FIELD_PREFIXES = ("employeeField_", "departmentSelectField_")
+
+
+def _fix_array_field_for_aggregate(field_code: str, data_type: str, aggregate_type: str) -> tuple[str, str]:
+    """数组字段做聚合时保留 _value 后缀（cube 元数据只认 _value），仅将 ARRAY 类型转为 STRING。"""
+    if aggregate_type == "NONE":
+        return field_code, data_type
+    if any(field_code.startswith(p) for p in _ARRAY_FIELD_PREFIXES):
+        import warnings
+        warnings.warn(
+            f"⚠ {field_code} 是数组字段，不能做聚合（{aggregate_type}）——"
+            f"cube SQL 会报 'aggregate cannot contain set-returning function'。"
+            f"请改用非数组字段（如 numberField / textField）做 {aggregate_type}。",
+            stacklevel=3,
+        )
+    if data_type == "ARRAY":
+        return field_code, "STRING"
+    return field_code, data_type
+
+
+def _is_date_field(field_code: str) -> bool:
+    return field_code.startswith("dateField_")
+
+
+def _gen_alias() -> str:
+    return f"field_{next_node_id()}"
+
+
+# ---------------------------------------------------------------------------
+# 字段解析：支持 string 或 rich field dict
+# ---------------------------------------------------------------------------
+
+
+def _resolve_field(raw: Any, cube_code: str) -> dict[str, Any]:
+    """把 string 或 dict 输入统一解析为标准字段元数据。"""
+    if isinstance(raw, dict):
+        fc = normalize_field_code(raw.get("fieldCode", ""))
+        if not fc:
+            raise ValueError(
+                f"fieldCode 不能为空。请先通过 `dws yida form components` 获取源表字段定义，"
+                f"使用返回的 fieldCode 构造字段对象。收到: {raw!r}"
+            )
+        text = raw.get("text") or raw.get("label") or _derive_label(fc)
+        text = _apply_cube_label_suffix(fc, text)
+        return {
+            "fieldCode": fc,
+            "dataType": raw.get("dataType") or _infer_data_type(fc),
+            "text": text,
+            "id": raw.get("id") or fc,
+            "classifiedCode": raw.get("classifiedCode") or cube_code,
+            "timeGranularityType": raw.get("timeGranularityType"),
+            "timeFormat": raw.get("timeFormat"),
+        }
+    fc = normalize_field_code(str(raw))
+    if not fc:
+        raise ValueError(
+            "fieldCode 不能为空字符串。请先通过 `dws yida form components` 获取源表字段定义。"
+        )
+    text = _apply_cube_label_suffix(fc, _derive_label(fc))
+    return {
+        "fieldCode": fc,
+        "dataType": _infer_data_type(fc),
+        "text": text,
+        "id": fc,
+        "classifiedCode": cube_code,
+        "timeGranularityType": None,
+        "timeFormat": None,
+    }
+
+
+# ---------------------------------------------------------------------------
+# 字段对象构造（匹配宜搭报表引擎格式）
+# ---------------------------------------------------------------------------
+
+
+def _build_query_field_def(
+    alias: str,
+    label: str,
+    cube_code: str,
+    field_code: str,
+    data_type: str,
+    aggregate_type: str = "NONE",
+    time_gran: Optional[str] = None,
+    classified_code: Optional[str] = None,
+) -> dict[str, Any]:
+    """dataViewQueryModel.fieldDefinitionList 中的单条定义。"""
+    return {
+        "classifiedCode": classified_code or cube_code,
+        "cubeCode": cube_code,
+        "fieldCode": field_code,
+        "dataType": data_type,
+        "isDim": False,
+        "aggregateType": aggregate_type,
+        "alias": alias,
+        "aliasName": {"type": "i18n", "zh_CN": label, "en_US": label},
+        "timeGranularityType": time_gran,
+    }
+
+
+def _build_full_field(
+    alias: str,
+    label: str,
+    cube_code: str,
+    field_code: str,
+    data_type: str,
+    aggregate_type: str = "NONE",
+    time_gran: Optional[str] = None,
+    classified_code: Optional[str] = None,
+    field_id: Optional[str] = None,
+    time_format: Optional[str] = None,
+) -> dict[str, Any]:
+    """外层 fieldList / xField / yField 中的完整字段对象。"""
+    fid = field_id or field_code
+    effective_dt = "DOUBLE" if aggregate_type in _AGGREGATE_TYPES else data_type
+    result: dict[str, Any] = {
+        "title": i18n(label),
+        "classifiedCode": classified_code or cube_code,
+        "cubeCode": cube_code,
+        "fieldCode": field_code,
+        "isDimension": "false",
+        "dataType": effective_dt,
+        "format": {"type": "NONE"},
+        "link": [{"type": "NONE"}],
+        "drillList": [],
+        "aggregateType": aggregate_type,
+        "orderBy": {"type": "NONE", "reference": alias},
+        "fieldKey": alias,
+        "visible": True,
+        "beUsedTimes": 1,
+        "isVisible": "y",
+        "id": fid,
+        "text": label,
+    }
+    if aggregate_type in _AGGREGATE_TYPES:
+        result["measureType"] = "MEASURE_ATTRIBUTE"
+    if time_gran:
+        result["timeGranularityType"] = time_gran
+        suffix = _TIME_GRAN_ID_SUFFIX.get(time_gran, "")
+        if suffix:
+            result["id"] = field_code + suffix
+        fmt = time_format or _TIME_GRAN_FORMAT.get(time_gran)
+        if fmt:
+            result["timeFormat"] = fmt
+    return result
+
+
+def _wrap_dataset(
+    ds_key: str,
+    cube_code: str,
+    cube_tenant_id: str,
+    query_field_defs: list[dict[str, Any]],
+    aliases: list[str],
+    full_fields: list[dict[str, Any]],
+    extra: Optional[dict[str, Any]] = None,
+    extra_query: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    """组装完整 dataSetModelMap（匹配宜搭报表引擎结构）。"""
+    query_model: dict[str, Any] = {
+        "cubeCode": cube_code,
+        "cubeTenantId": cube_tenant_id,
+        "fieldDefinitionList": query_field_defs,
+        "fieldList": aliases,
+        "filterList": [],
+        "orderByList": [],
+    }
+    if extra_query:
+        query_model.update(extra_query)
+
+    ds: dict[str, Any] = {
+        "cubeCodes": [cube_code],
+        "dataViewQueryModel": query_model,
+        "fieldList": full_fields,
+        "youshuDataType": "real",
+        "filterList": [],
+        "limit": "",
+        "mockData": [],
+    }
+
+    if extra:
+        ds.update(extra)
+    return {ds_key: ds}
+
+
+# ---------------------------------------------------------------------------
+# 图表 settings 默认值
+# ---------------------------------------------------------------------------
+
+_AXIS_LABEL_STYLE = {
+    "labelType": "default",
+    "color": "rgba(23,26,29,0.4)",
+    "fontSize": 12,
+    "limitLengthType": "percent",
+    "percent": 30,
+    "value": 100,
+    "autoRotate": True,
+    "rotate": "0",
+    "autoHide": True,
+}
+
+_X_AXIS_DEFAULT = {
+    "showXAxis": True,
+    "showTitle": False,
+    "title": {"type": "i18n", "zh_CN": "", "en_US": ""},
+    "line": True,
+    "tickLine": True,
+    "grid": False,
+    "label": True,
+    "labelStyle": _AXIS_LABEL_STYLE,
+    "values": {"type": "i18n", "zh_CN": "", "en_US": ""},
+}
+
+_Y_AXIS_DEFAULT = {
+    "showYAxis": True,
+    "showTitle": False,
+    "title": {"type": "i18n", "zh_CN": "", "en_US": ""},
+    "line": False,
+    "tickLine": False,
+    "grid": True,
+    "label": True,
+    "labelStyle": _AXIS_LABEL_STYLE,
+    "min": None,
+    "max": None,
+    "tickCount": 5,
+}
+
+_CUSTOM_COLOR = "#5894FF,#394B76,#F7B900,#E55F24,#80D5F5,#9849B0,#3BC88A,#0E869D,#F4A49E,#80563C"
+
+_LEGEND_DEFAULT = {"showLegend": True, "legendPosition": "top-left", "flipPage": True}
+
+
+def _get_chart_settings(chart_type: str, chart: dict[str, Any]) -> dict[str, Any]:
+    if chart_type == "bar":
+        return {
+            "container": {"height": 248},
+            "style": {
+                "mode": "group",
+                "linkGroup": False,
+                "transpose": False,
+                "barStyle": "ai",
+                "size": None,
+                "maxSize": None,
+                "minSize": None,
+                "barBackground": None,
+                "groupSpacing": 0,
+                "radiusLeftTop": 4,
+                "radiusRightTop": 4,
+                "radiusRightBottom": 0,
+                "radiusLeftBottom": 0,
+                "colorType": "CUSTOM_COLOR",
+                "chartColorsMode": "EHRColorsMode",
+                "customColor": _CUSTOM_COLOR,
+            },
+            "countLabel": {"showCountLabel": False, "fontSize": 12, "color": "#000"},
+            "axisType": "hz",
+            "xAxis": _X_AXIS_DEFAULT,
+            "yAxis": _Y_AXIS_DEFAULT,
+            "legend": _LEGEND_DEFAULT,
+            "label": {
+                "showLabel": True,
+                "labelShowStyle": "ai",
+                "fontSize": 12,
+                "autoColor": True,
+                "color": "#000",
+                "autoPosition": False,
+                "position": "middle",
+                "autoAdjust": True,
+                "autoHide": True,
+            },
+            "slider": {"showSlider": False},
+            "tooltip": {"showTooltip": True},
+        }
+    elif chart_type == "line":
+        return {
+            "container": {"height": 248},
+            "style": {
+                "mode": "none",
+                "lineStyle": "ai",
+                "lineSize": 2,
+                "smooth": False,
+                "showArea": False,
+                "areaOpacity": 0.25,
+                "showPoint": True,
+                "pointSize": 4,
+                "pointShape": "circle",
+                "showLine": True,
+                "lineWidth": 2,
+                "colorType": "CUSTOM_COLOR",
+                "chartColorsMode": "EHRColorsMode",
+                "customColor": _CUSTOM_COLOR,
+            },
+            "axisType": "hz",
+            "xAxis": _X_AXIS_DEFAULT,
+            "yAxis": _Y_AXIS_DEFAULT,
+            "legend": _LEGEND_DEFAULT,
+            "label": {"showLabel": True, "fontSize": 12, "color": "#000", "autoOverlap": True},
+            "slider": {"showSlider": False},
+            "tooltip": {"showTooltip": True},
+        }
+    elif chart_type == "pie":
+        return {
+            "container": {"height": 248},
+            "style": {
+                "radius": 75,
+                "isRing": False,
+                "innerRadius": 0,
+                "colorType": "CUSTOM_COLOR",
+                "chartColorsMode": "EHRColorsMode",
+                "customColor": _CUSTOM_COLOR,
+            },
+            "statistic": {"showStatistic": False},
+            "label": {
+                "showLabel": True,
+                "showLine": True,
+                "labelAlign": "outer",
+                "labelSize": 12,
+                "labelColor": "#404040",
+                "labelFormatType": "NAME_PERCENT",
+            },
+            "legend": {
+                "showLegend": True,
+                "legendPosition": "right",
+                "flipPage": True,
+                "type": "item",
+                "contentType": "NAME",
+                "cardWidth": None,
+                "ratio": 65,
+                "layout": "vertical",
+                "itemSpacing": 12,
+            },
+            "tooltip": {"showTooltip": True, "contentType": None},
+            "percentDigits": 2,
+        }
+    elif chart_type == "funnel":
+        return {
+            "container": {"height": 248},
+            "style": {
+                "colorType": "CUSTOM_COLOR",
+                "chartColorsMode": "EHRColorsMode",
+                "customColor": _CUSTOM_COLOR,
+            },
+            "legend": _LEGEND_DEFAULT,
+            "label": {"showLabel": True, "fontSize": 12, "color": "#000"},
+            "tooltip": {"showTooltip": True},
+        }
+    elif chart_type == "gauge":
+        return {
+            "container": {"height": 248},
+            "useSingleColor": False,
+            "singleColor": "#0089FF",
+            "color": [],
+            "tick": {"showTick": True, "min": None, "max": None, "tickInterval": None},
+            "assistValue": {"openAssistValue": True, "showCompare": False, "position": "bottom"},
+            "style": {"rounded": True, "pivot": True, "rangeSize": 16, "radius": 95, "innerRadius": 90},
+        }
+    elif chart_type == "combo":
+        return {
+            "container": {"height": 248},
+            "style": {
+                "sync": False,
+                "chartType": "bar-line",
+                "bar": {
+                    "size": None, "maxSize": None, "minSize": None, "mode": "group",
+                    "barBackground": None,
+                    "radiusLeftTop": 4, "radiusRightTop": 4,
+                    "radiusRightBottom": 0, "radiusLeftBottom": 0,
+                },
+                "line": {
+                    "size": 2, "smooth": False,
+                    "showPoint": True, "pointSize": 4, "pointShape": "circle",
+                },
+                "autoAdjust": True,
+                "colorType": "CUSTOM_COLOR",
+                "chartColorsMode": "EHRColorsMode",
+                "customColor": _CUSTOM_COLOR,
+            },
+            "xAxis": _X_AXIS_DEFAULT,
+            "leftYAxis": {
+                "showLeftYAxis": True, "showTitle": False,
+                "title": {"type": "i18n", "zh_CN": "", "en_US": ""},
+                "line": False, "tickLine": False, "grid": True, "label": True,
+                "labelStyle": _AXIS_LABEL_STYLE,
+                "min": None, "max": None, "tickCount": 5,
+            },
+            "rightYAxis": {
+                "showRightYAxis": True, "showTitle": False,
+                "title": {"type": "i18n", "zh_CN": "", "en_US": ""},
+                "line": False, "tickLine": False, "grid": False, "label": True,
+                "labelStyle": _AXIS_LABEL_STYLE,
+                "min": None, "max": None, "tickCount": 5,
+            },
+            "legend": _LEGEND_DEFAULT,
+            "leftLabel": {"showLabel": True, "fontSize": 12, "color": "#000"},
+            "rightLabel": {"showLabel": True, "fontSize": 12, "color": "#000"},
+            "slider": {"showSlider": False},
+            "tooltip": {"showTooltip": True},
+        }
+    elif chart_type == "table":
+        page_size = chart.get("pageSize", 20)
+        return {
+            "rglConfig": {"w": 6, "h": 21, "isHeightAuto": True},
+            "size": "medium",
+            "wordSize": "medium:14",
+            "theme": "split",
+            "mergeCell": False,
+            "fixedHeader": False,
+            "maxBodyHeight": "300",
+            "fixedColumnIndex": 1,
+            "isReverseTable": False,
+            "showReversedHeader": False,
+            "isUniqueRows": False,
+            "pagination": {
+                "isPagination": True,
+                "pageSize": page_size,
+                "pageShowCount": 5,
+                "showPageSelect": False,
+                "size": "small",
+                "type": "normal",
+            },
+            "isTree": False,
+            "idField": None,
+            "pidField": None,
+            "isLeaf": None,
+            "drilldownFilterList": None,
+            "defaultExpand": False,
+            "rankStyle": False,
+            "container": {"height": 472},
+            "titleTip": False,
+            "showCopyData": False,
+            "enableFieldSelect": False,
+            "defaultSelectedFields": "",
+            "hasFullscreen": False,
+            "copyAsImg": False,
+            "height": None,
+            "isHeightAuto": True,
+        }
+    elif chart_type == "indicator":
+        kpi_count = len(chart.get("kpi", []))
+        return {
+            "showSideStyle": "NONE",
+            "followTheme": False,
+            "themeType": "dark",
+            "showSideBorder": True,
+            "sideBarColor": "#0089FF",
+            "bgColorType": "single",
+            "singleBgColor": "#F1F2F3",
+            "colorType": "SCHEMA_COLOR",
+            "multipleBgColor": "defaultColorsMode",
+            "customColor": "#0089FF,#FF9200,#11AB4F,#FFD100,#7263EE,#67C5EB,#6B748C,#FF755A,#007E99,#FFA8A8",
+            "size": "normal",
+            "valueSize": "20px",
+            "titleMaxRow": 0,
+            "columnCount": min(kpi_count, 4) or 4,
+            "columnCountForH5": min(kpi_count, 2) or 2,
+            "popoverAlign": "b",
+            "container": {"height": 72},
+            "titleTip": False,
+            "enableFieldSelect": False,
+            "hasFullscreen": False,
+            "copyAsImg": False,
+            "height": None,
+            "isHeightAuto": True,
+        }
+    elif chart_type == "pivot":
+        return {
+            "rglConfig": {"w": 6, "h": 21, "isHeightAuto": True},
+            "maxBodyHeight": 500,
+            "size": "normal",
+            "rows": [],
+            "columns": [],
+            "measures": [],
+            "details": [],
+            "supportExport": False,
+            "exportType": "XJZ",
+            "dialogWidth": 850,
+            "dialogPageSize": 10,
+            "baseInfo": {
+                "isShowSetter": True, "isShowFilter": False, "isShowReload": False,
+                "isHideTitle": False, "isMeasureOrder": True, "isZebra": True,
+                "rowMaxSize": 3000, "columnsMaxSize": 500, "columnWidth": 100,
+                "dialogWidth": 850, "dialogPageSize": 10,
+                "detailExportData": {"supportExport": False, "exportType": "BROWSER"},
+            },
+            "mode": "summary",
+            "summaryInfo": {
+                "isRowTotal": True, "rowTotalWidth": 130, "rowTotalPosition": "end",
+                "isColumnTotal": True, "isSubTotal": False,
+                "rowMaxSize": 3000, "columnsMaxSize": 500,
+            },
+            "paginationInfo": {
+                "size": "small", "type": "normal", "pageShowCount": 5,
+                "pageSize": 10, "showPageSelect": False,
+            },
+            "container": {"height": 232},
+            "titleTip": False,
+            "hasFullscreen": False,
+            "copyAsImg": False,
+            "height": None,
+            "isHeightAuto": True,
+        }
+    return {}
+
+
+# ---------------------------------------------------------------------------
+# userConfig 构建（设计器数据配置面板）
+# ---------------------------------------------------------------------------
+
+def _setter(name: str, title: str, **extra_props: Any) -> dict[str, Any]:
+    item: dict[str, Any] = {"setterName": "ColumnFieldSetter", "name": name, "title": title}
+    if extra_props:
+        item["setterProps"] = extra_props
+    return item
+
+
+def _build_user_config(chart_type: str) -> list[dict[str, Any]]:
+    if chart_type in ("bar", "line"):
+        return [{"name": _DS_KEY_CHART, "title": "配置数据", "items": [
+            _setter("xField", "横轴", single=True, showFormatTab=True, showFormulaEditor=True,
+                    showFieldInfo=True, showAggregateTab=False, showDrillTab=True, showEditTab=True, showSortTab=True),
+            _setter("yField", "纵轴", showFormatTab=True, showFormulaEditor=True,
+                    showFieldInfo=True, showEditTab=True, showSortTab=True, showDataLink=True),
+            _setter("groupField", "分组", single=True, showFormatTab=True, showEditTab=True),
+            _setter("annotationField", "参考线", showFormatTab=True, showEditTab=True),
+        ]}]
+    if chart_type == "pie":
+        return [{"name": _DS_KEY_CHART, "title": "配置数据", "items": [
+            _setter("xField", "分类字段", single=True, showAggregateTab=False, showDrillTab=True, showColorTab=True),
+            _setter("yField", "数值字段", single=True, showDataLink=True),
+            _setter("ratio", "趋势值字段"),
+            _setter("totalValue", "总值字段"),
+            _setter("totalRatio", "总趋势值字段"),
+        ]}]
+    if chart_type == "funnel":
+        return [{"name": _DS_KEY_CHART, "title": "配置数据", "items": [
+            _setter("xField", "横轴", single=True, showFormatTab=True, showAggregateTab=False,
+                    showDrillTab=True, showEditTab=True, showSortTab=True),
+            _setter("yField", "纵轴", showFormatTab=True, showEditTab=True, showSortTab=True, showDataLink=True),
+        ]}]
+    if chart_type == "combo":
+        return [{"name": _DS_KEY_DATASET, "title": "配置数据", "items": [
+            _setter("xField", "横轴", single=True),
+            _setter("leftYFields", "左纵轴", showDataLink=True),
+            _setter("rightYFields", "右纵轴", showDataLink=True),
+            _setter("annotationField", "参考线"),
+        ]}]
+    if chart_type == "table":
+        return [{"name": _DS_KEY_TABLE, "title": "配置数据", "items": [
+            _setter("columnFields", "列", showFormulaEditor=True, showFieldInfo=True,
+                    showDataLink=True, supportDynamicAlias=True, showBatchSet=True,
+                    batchSetFields=["text", "title", "aggregateType", "format_type", "format_decimalDigit"]),
+        ]}]
+    if chart_type == "indicator":
+        return [{"name": _DS_KEY_INDICATOR, "title": "指标数据", "items": [
+            _setter("kpi", "指标", single=False, showDataLink=True, supportDynamicAlias=True,
+                    showBatchSet=True,
+                    batchSetFields=["text", "title", "titleTip", "aggregateType",
+                                    "format_type", "format_decimalDigit", "unit"]),
+            _setter("helpKpi", "辅助指标", single=False, showDataLink=True),
+        ]}]
+    if chart_type == "pivot":
+        return [{"name": _DS_KEY_DATASET, "title": "配置数据", "items": [
+            _setter("columnList", "列", showFormatTab=True, showEditTab=True),
+        ]}]
+    if chart_type == "gauge":
+        return [{"name": _DS_KEY_CHART, "title": "配置数据", "items": [
+            _setter("valueField", "指标值", single=True),
+            _setter("assitValueField", "辅助值", single=True),
+        ]}]
+    return []
+
+
+# ---------------------------------------------------------------------------
+# mockData 构建（设计器预览数据）
+# ---------------------------------------------------------------------------
+
+def _build_mock_data(chart_type: str) -> list[dict[str, Any]]:
+    if chart_type == "bar":
+        return [{"name": _DS_KEY_CHART, "data": {"data": [
+            {"month": "Jan.", "value": 18.9}, {"month": "Feb.", "value": 28.8},
+            {"month": "Mar.", "value": 39.3}, {"month": "Apr.", "value": 81.4},
+            {"month": "May", "value": 47},
+        ], "meta": [
+            {"fieldKey": "xField", "dataType": "STRING", "title": "month"},
+            {"fieldKey": "yField", "dataType": "NUMBER", "title": "value"},
+        ], "currentPage": 1, "totalCount": 5}}]
+
+    if chart_type == "line":
+        return [{"name": _DS_KEY_CHART, "data": {"data": [
+            {"xField": "2020", "yField": 3}, {"xField": "2021", "yField": 4},
+            {"xField": "2022", "yField": 3.5}, {"xField": "2023", "yField": 5},
+            {"xField": "2024", "yField": 4.9},
+        ], "meta": [
+            {"fieldKey": "xField", "dataType": "STRING", "title": "xField"},
+            {"fieldKey": "yField", "dataType": "NUMBER", "title": "yField"},
+        ], "currentPage": 1, "totalCount": 5}}]
+
+    if chart_type == "pie":
+        return [{"name": _DS_KEY_CHART, "data": {"data": [
+            {"xField": "分类A", "yField": 63, "ratio": 0.8, "totalValue": 202, "totalRatio": 0.32},
+            {"xField": "分类B", "yField": 72, "ratio": 0.5, "totalValue": 202, "totalRatio": 0.36},
+            {"xField": "分类C", "yField": 67, "ratio": 0.3, "totalValue": 202, "totalRatio": 0.33},
+        ], "meta": [
+            {"fieldKey": "xField", "dataType": "STRING", "title": "xField"},
+            {"fieldKey": "yField", "dataType": "NUMBER", "title": "yField"},
+            {"fieldKey": "ratio", "dataType": "NUMBER", "title": "ratio"},
+            {"fieldKey": "totalValue", "dataType": "NUMBER", "title": "totalValue"},
+            {"fieldKey": "totalRatio", "dataType": "NUMBER", "title": "totalRatio"},
+        ], "currentPage": 1, "totalCount": 3}}]
+
+    if chart_type == "funnel":
+        return [{"name": _DS_KEY_CHART, "data": {"data": [
+            {"xField": "展示", "yField": 100}, {"xField": "点击", "yField": 80},
+            {"xField": "访问", "yField": 60}, {"xField": "咨询", "yField": 40},
+            {"xField": "订单", "yField": 20},
+        ], "meta": [
+            {"fieldKey": "xField", "dataType": "STRING", "title": "xField"},
+            {"fieldKey": "yField", "dataType": "NUMBER", "title": "yField"},
+        ], "currentPage": 1, "totalCount": 5}}]
+
+    if chart_type == "gauge":
+        return [{"name": _DS_KEY_CHART, "data": {"data": [
+            {"value": 75, "assitValue": 100},
+        ], "meta": [
+            {"fieldKey": "valueField", "dataType": "NUMBER", "title": "value"},
+            {"fieldKey": "assitValueField", "dataType": "NUMBER", "title": "assitValue"},
+        ], "currentPage": 1, "totalCount": 1}}]
+
+    if chart_type == "combo":
+        return [{"name": _DS_KEY_DATASET, "data": {"data": [
+            {"xField": "Jan.", "leftY": 18.9, "rightY": 5},
+            {"xField": "Feb.", "leftY": 28.8, "rightY": 8},
+            {"xField": "Mar.", "leftY": 39.3, "rightY": 12},
+            {"xField": "Apr.", "leftY": 81.4, "rightY": 15},
+            {"xField": "May", "leftY": 47, "rightY": 10},
+        ], "meta": [
+            {"fieldKey": "xField", "dataType": "STRING", "title": "xField"},
+            {"fieldKey": "leftYFields", "dataType": "NUMBER", "title": "leftY"},
+            {"fieldKey": "rightYFields", "dataType": "NUMBER", "title": "rightY"},
+        ], "currentPage": 1, "totalCount": 5}}]
+
+    if chart_type == "table":
+        return [{"name": _DS_KEY_TABLE, "data": {"data": [
+            {"col1": "数据1", "col2": "数据2", "col3": 100},
+            {"col1": "数据4", "col2": "数据5", "col3": 200},
+            {"col1": "数据7", "col2": "数据8", "col3": 300},
+        ], "meta": [
+            {"fieldKey": "columnFields", "dataType": "STRING", "title": "col1"},
+            {"fieldKey": "columnFields", "dataType": "STRING", "title": "col2"},
+            {"fieldKey": "columnFields", "dataType": "NUMBER", "title": "col3"},
+        ], "currentPage": 1, "totalCount": 3}}]
+
+    if chart_type == "indicator":
+        return [{"name": _DS_KEY_INDICATOR, "data": {"data": [
+            {"kpi1": 23123, "kpi2": 7712},
+        ], "meta": [
+            {"fieldKey": "kpi1", "dataType": "NUMBER", "title": "指标1", "category": "kpi"},
+            {"fieldKey": "kpi2", "dataType": "NUMBER", "title": "指标2", "category": "kpi"},
+        ], "currentPage": 1, "totalCount": 1}}]
+
+    if chart_type == "pivot":
+        return [{"name": _DS_KEY_DATASET, "data": {"data": [
+            {"col1": 74, "col2": 9, "col3": 79},
+            {"col1": 85, "col2": 15, "col3": 62},
+            {"col1": 93, "col2": 28, "col3": 44},
+        ], "meta": [
+            {"fieldKey": "columnList", "dataType": "NUMBER", "title": "col1"},
+            {"fieldKey": "columnList", "dataType": "NUMBER", "title": "col2"},
+            {"fieldKey": "columnList", "dataType": "NUMBER", "title": "col3"},
+        ], "currentPage": 1, "totalCount": 3}}]
+
+    return []
+
+
+# ---------------------------------------------------------------------------
+# afterFetch / exportData / link 构建
+# ---------------------------------------------------------------------------
+
+_AFTER_FETCH = {
+    "type": "JSFunction",
+    "value": "function afterFetch(data, extraInfo) { return data; }",
+}
+
+_EXPORT_DATA = {
+    "supportExport": False,
+    "passType": "NO_PASS",
+    "exportType": "BROWSER",
+}
+
+_LINK = {
+    "hasLink": False,
+    "content": {"type": "i18n", "zh_CN": "更多", "en_US": "More"},
+    "onlyIcon": True,
+}
+
+
+# ---------------------------------------------------------------------------
+# 顶层字段属性提取
+# ---------------------------------------------------------------------------
+
+def _extract_top_level_field_props(chart_type: str, ds_model_map: dict[str, Any]) -> dict[str, Any]:
+    """从 dataSetModelMap 提取需要写入 props 顶层的字段属性。"""
+    result: dict[str, Any] = {}
+    if chart_type in ("bar", "line", "pie", "funnel"):
+        ds = ds_model_map.get(_DS_KEY_CHART, {})
+        result["xField"] = ds.get("xField", [])
+        result["yField"] = ds.get("yField", [])
+        if chart_type not in ("pie", "funnel"):
+            result["groupField"] = ds.get("groupField", [])
+    elif chart_type == "gauge":
+        ds = ds_model_map.get(_DS_KEY_CHART, {})
+        result["valueField"] = ds.get("valueField", [])
+        result["assitValueField"] = ds.get("assitValueField", [])
+    elif chart_type == "indicator":
+        ds = ds_model_map.get(_DS_KEY_INDICATOR, {})
+        result["kpiField"] = ds.get("kpi", [])
+        result["helpKpiField"] = ds.get("helpKpi", [])
+    elif chart_type == "table":
+        ds = ds_model_map.get(_DS_KEY_TABLE, {})
+        result["columnField"] = ds.get("columnFields", [])
+    elif chart_type == "combo":
+        ds = ds_model_map.get(_DS_KEY_DATASET, {})
+        result["xField"] = ds.get("xField", [])
+        result["leftYFields"] = ds.get("leftYFields", [])
+        result["rightYFields"] = ds.get("rightYFields", [])
+    elif chart_type == "pivot":
+        ds = ds_model_map.get(_DS_KEY_DATASET, {})
+        result["columnList"] = ds.get("columnList", [])
+    return result
+
+
+# ---------------------------------------------------------------------------
+# 主入口
+# ---------------------------------------------------------------------------
+
+
+def build_chart_component(
+    chart: dict[str, Any],
+    cube_tenant_id: str = "",
+) -> tuple[dict[str, Any], str, dict[str, Any]]:
+    """
+    构造图表组件。
+
+    Returns:
+        (component_node, fieldId, default_layout)
+    """
+    chart_type = chart.get("type", "bar")
+    if chart_type not in CHART_TYPE_MAP:
+        raise ValueError(f"不支持的图表类型: {chart_type}（支持: {list(CHART_TYPE_MAP.keys())}）")
+
+    component_name = CHART_TYPE_MAP[chart_type]
+    title = chart.get("title", "图表")
+    field_id = generate_field_id(component_name)
+    node_id = next_node_id()
+
+    cube_code = normalize_cube_code(chart.get("cubeCode", ""))
+    if not cube_code:
+        raise ValueError(f"图表 '{title}' 缺少 cubeCode")
+
+    data_set_model_map = _build_data_set_model_map(chart, cube_code, cube_tenant_id)
+
+    props: dict[str, Any] = {
+        "fieldId": field_id,
+        "cid": node_id,
+        "showComponentTitle": True,
+        "componentTitle": i18n(title),
+        "componentTitleTextAlign": "LEFT",
+        "titleTipContent": i18n(""),
+        "titleTipIconName": "help",
+        "headerSize": "medium",
+        "link": _LINK,
+        "exportData": _EXPORT_DATA,
+        "openRefresh": True,
+        "enabledCache": True,
+        "auth": [],
+        "afterFetch": _AFTER_FETCH,
+        "__style__": {},
+        "mockData": _build_mock_data(chart_type),
+        "dataSetModelMap": data_set_model_map,
+        "userConfig": _build_user_config(chart_type),
+        "settings": _get_chart_settings(chart_type, chart),
+        "titleTip": False,
+        "hasFullscreen": False,
+        "copyAsImg": False,
+        "height": None,
+        "isHeightAuto": True,
+        "datasetModel": {"filterList": []},
+    }
+
+    top_level = _extract_top_level_field_props(chart_type, data_set_model_map)
+    props.update(top_level)
+
+    if chart_type in ("table", "indicator"):
+        props["showFieldSelectIcon"] = True
+
+    if chart_type == "table":
+        props["pageSize"] = chart.get("pageSize", 20)
+
+    node: dict[str, Any] = {
+        "componentName": component_name,
+        "id": node_id,
+        "props": props,
+    }
+
+    computed = _compute_dynamic_layout(chart_type, chart)
+    layout: dict[str, Any] = {
+        "w": chart.get("w", computed["w"]),
+        "h": chart.get("h", computed["h"]),
+    }
+    for k in ("minH", "maxH", "resizeHandles"):
+        if k in computed:
+            layout[k] = computed[k]
+
+    return node, field_id, layout
+
+
+# ---------------------------------------------------------------------------
+# dataSetModelMap 构造
+# ---------------------------------------------------------------------------
+
+
+def _build_data_set_model_map(
+    chart: dict[str, Any],
+    cube_code: str,
+    cube_tenant_id: str,
+) -> dict[str, Any]:
+    chart_type = chart.get("type", "bar")
+
+    if chart_type in ("bar", "line", "pie", "funnel"):
+        return _build_xy_data_model(chart, cube_code, cube_tenant_id)
+    elif chart_type == "table":
+        return _build_table_data_model(chart, cube_code, cube_tenant_id)
+    elif chart_type == "indicator":
+        return _build_indicator_data_model(chart, cube_code, cube_tenant_id)
+    elif chart_type == "gauge":
+        return _build_gauge_data_model(chart, cube_code, cube_tenant_id)
+    elif chart_type == "combo":
+        return _build_combo_data_model(chart, cube_code, cube_tenant_id)
+    elif chart_type == "pivot":
+        return _build_pivot_data_model(chart, cube_code, cube_tenant_id)
+    return {}
+
+
+def _build_xy_data_model(
+    chart: dict[str, Any],
+    cube_code: str,
+    cube_tenant_id: str,
+) -> dict[str, Any]:
+    chart_type = chart.get("type", "bar")
+    x_raw = chart.get("xField", "")
+    x_resolved = _resolve_field(x_raw, cube_code)
+
+    y_raw = chart.get("yField", "")
+    if isinstance(y_raw, (str, dict)):
+        y_raw = [y_raw]
+    y_resolved_list = [_resolve_field(f, cube_code) for f in y_raw]
+
+    agg_type = chart.get("aggregateType", "COUNT").upper()
+
+    x_label = _apply_cube_label_suffix(
+        x_resolved["fieldCode"], chart.get("xLabel", "") or x_resolved["text"]
+    )
+    y_labels_raw = chart.get("yLabel", [])
+    if isinstance(y_labels_raw, str):
+        y_labels_raw = [y_labels_raw]
+
+    x_alias = _gen_alias()
+    x_time_gran = x_resolved["timeGranularityType"] or (
+        chart.get("timeGranularityType", "DAY") if _is_date_field(x_resolved["fieldCode"]) else None
+    )
+
+    query_defs = [_build_query_field_def(
+        x_alias, x_label, cube_code, x_resolved["fieldCode"], x_resolved["dataType"],
+        "NONE", x_time_gran, classified_code=x_resolved["classifiedCode"],
+    )]
+    x_full = _build_full_field(
+        x_alias, x_label, cube_code, x_resolved["fieldCode"], x_resolved["dataType"],
+        "NONE", x_time_gran, classified_code=x_resolved["classifiedCode"],
+        field_id=x_resolved["id"], time_format=x_resolved["timeFormat"],
+    )
+    all_full = [x_full]
+
+    y_aliases: list[str] = []
+    y_fulls: list[dict[str, Any]] = []
+    for i, yr in enumerate(y_resolved_list):
+        y_label = _apply_cube_label_suffix(
+            yr["fieldCode"], (y_labels_raw[i] if i < len(y_labels_raw) else "") or yr["text"]
+        )
+        y_alias = _gen_alias()
+        y_aliases.append(y_alias)
+        y_fc, y_dt = _fix_array_field_for_aggregate(yr["fieldCode"], yr["dataType"], agg_type)
+        query_defs.append(_build_query_field_def(
+            y_alias, y_label, cube_code, y_fc, y_dt,
+            agg_type, classified_code=yr["classifiedCode"],
+        ))
+        y_full = _build_full_field(
+            y_alias, y_label, cube_code, y_fc, y_dt,
+            agg_type, classified_code=yr["classifiedCode"], field_id=yr["id"],
+        )
+        y_fulls.append(y_full)
+        all_full.append(y_full)
+
+    extra: dict[str, Any] = {"xField": [x_full], "yField": y_fulls}
+    if chart_type == "pie":
+        extra.update({"ratio": [], "totalValue": [], "totalRatio": [], "trailingIconField": []})
+    elif chart_type != "funnel":
+        extra.update({"groupField": [], "annotationField": []})
+
+    limit_val = chart.get("limit")
+    if limit_val is not None:
+        extra["limit"] = int(limit_val)
+
+    return _wrap_dataset(
+        _DS_KEY_CHART, cube_code, cube_tenant_id,
+        query_defs, [x_alias] + y_aliases, all_full,
+        extra=extra,
+    )
+
+
+def _build_table_data_model(
+    chart: dict[str, Any],
+    cube_code: str,
+    cube_tenant_id: str,
+) -> dict[str, Any]:
+    raw_columns = chart.get("columnFields", []) or chart.get("columns", []) or chart.get("fields", [])
+    if not raw_columns:
+        x_field = chart.get("xField", "")
+        if x_field:
+            raw_columns = [x_field]
+    if not raw_columns:
+        raise ValueError(
+            "table 图表必须提供 columnFields（或 columns / fields / xField）。"
+            "请先通过 `dws yida form components` 获取源表字段定义。"
+        )
+
+    column_labels_raw = chart.get("columnLabels", [])
+    resolved_columns = [_resolve_field(col, cube_code) for col in raw_columns]
+
+    query_defs: list[dict[str, Any]] = []
+    aliases: list[str] = []
+    full_fields: list[dict[str, Any]] = []
+
+    for i, rc in enumerate(resolved_columns):
+        label = _apply_cube_label_suffix(
+            rc["fieldCode"], (column_labels_raw[i] if i < len(column_labels_raw) else "") or rc["text"]
+        )
+        alias = _gen_alias()
+        aliases.append(alias)
+        time_gran = rc["timeGranularityType"] or (
+            chart.get("timeGranularityType", "DAY") if _is_date_field(rc["fieldCode"]) else None
+        )
+        query_defs.append(_build_query_field_def(
+            alias, label, cube_code, rc["fieldCode"], rc["dataType"],
+            "NONE", time_gran, classified_code=rc["classifiedCode"],
+        ))
+        full = _build_full_field(
+            alias, label, cube_code, rc["fieldCode"], rc["dataType"],
+            "NONE", time_gran, classified_code=rc["classifiedCode"],
+            field_id=rc["id"], time_format=rc["timeFormat"],
+        )
+        full["sortable"] = False
+        full["hidden"] = False
+        full_fields.append(full)
+
+    column_fields: list[dict[str, Any]] = []
+    for i, full in enumerate(full_fields):
+        col: dict[str, Any] = {
+            "aggregateType": full["aggregateType"],
+            "beUsedTimes": 1,
+            "classifiedCode": full["classifiedCode"],
+            "cubeCode": full["cubeCode"],
+            "dataType": full["dataType"],
+            "fieldCode": full["fieldCode"],
+            "fieldKey": full["fieldKey"],
+            "id": full["id"],
+            "text": full["text"],
+            "title": full["title"],
+            "visible": True,
+            "width": 120,
+            "align": "left",
+            "fixed": "left" if i == 0 else None,
+            "timeGranularityType": full.get("timeGranularityType"),
+            "timeFormat": full.get("timeFormat"),
+            "orderBy": full["orderBy"],
+        }
+        column_fields.append(col)
+
+    return _wrap_dataset(
+        _DS_KEY_TABLE, cube_code, cube_tenant_id,
+        query_defs, aliases, full_fields,
+        extra={"columnFields": column_fields},
+    )
+
+
+def _build_indicator_data_model(
+    chart: dict[str, Any],
+    cube_code: str,
+    cube_tenant_id: str,
+) -> dict[str, Any]:
+    kpi_list = chart.get("kpi", []) or chart.get("kpiField", []) or chart.get("yField", []) or chart.get("fields", [])
+    if not kpi_list:
+        raise ValueError("indicator 图表必须提供 kpi（或 kpiField / yField / fields）数组")
+
+    query_defs: list[dict[str, Any]] = []
+    aliases: list[str] = []
+    full_fields: list[dict[str, Any]] = []
+
+    kpi_rich: list[dict[str, Any]] = []
+    for kpi in kpi_list:
+        if isinstance(kpi, str):
+            kpi = {"fieldCode": kpi}
+        fc = normalize_field_code(kpi.get("fieldCode", ""))
+        agg = kpi.get("aggregateType", "COUNT").upper()
+        dt = kpi.get("dataType") or _infer_data_type(fc)
+        fc, dt = _fix_array_field_for_aggregate(fc, dt, agg)
+        label = kpi.get("aliasName", "") or kpi.get("text", "") or kpi.get("label", "") or _derive_label(fc)
+        label = _apply_cube_label_suffix(fc, label)
+        field_id = kpi.get("id") or fc
+        classified_code = kpi.get("classifiedCode") or cube_code
+        alias = _gen_alias()
+        aliases.append(alias)
+        query_defs.append(_build_query_field_def(
+            alias, label, cube_code, fc, dt, agg, classified_code=classified_code,
+        ))
+        full = _build_full_field(
+            alias, label, cube_code, fc, dt, agg,
+            classified_code=classified_code, field_id=field_id,
+        )
+        full_fields.append(full)
+        kpi_item: dict[str, Any] = {
+            **full,
+            "visible": True,
+            "isVisible": "y",
+        }
+        kpi_rich.append(kpi_item)
+
+    help_kpi_list = chart.get("helpKpi", [])
+    help_kpi_rich: list[dict[str, Any]] = []
+    for hk in help_kpi_list:
+        if isinstance(hk, str):
+            hk = {"fieldCode": hk}
+        fc = normalize_field_code(hk.get("fieldCode", ""))
+        agg = hk.get("aggregateType", "COUNT").upper()
+        dt = hk.get("dataType") or _infer_data_type(fc)
+        fc, dt = _fix_array_field_for_aggregate(fc, dt, agg)
+        label = hk.get("aliasName", "") or hk.get("text", "") or hk.get("label", "") or _derive_label(fc)
+        label = _apply_cube_label_suffix(fc, label)
+        field_id = hk.get("id") or fc
+        classified_code = hk.get("classifiedCode") or cube_code
+        alias = _gen_alias()
+        aliases.append(alias)
+        query_defs.append(_build_query_field_def(
+            alias, label, cube_code, fc, dt, agg, classified_code=classified_code,
+        ))
+        full = _build_full_field(
+            alias, label, cube_code, fc, dt, agg,
+            classified_code=classified_code, field_id=field_id,
+        )
+        full_fields.append(full)
+        help_kpi_rich.append({**full, "visible": True, "isVisible": "y"})
+
+    return _wrap_dataset(
+        _DS_KEY_INDICATOR, cube_code, cube_tenant_id,
+        query_defs, aliases, full_fields,
+        extra={"kpi": kpi_rich, "helpKpi": help_kpi_rich},
+    )
+
+
+def _build_gauge_data_model(
+    chart: dict[str, Any],
+    cube_code: str,
+    cube_tenant_id: str,
+) -> dict[str, Any]:
+    value_raw = chart.get("valueField") or chart.get("yField")
+    if isinstance(value_raw, list):
+        value_raw = value_raw[0] if value_raw else None
+    if not value_raw:
+        raise ValueError("gauge 图表必须提供 valueField（或 yField）")
+
+    value_resolved = _resolve_field(value_raw, cube_code)
+    agg_type = chart.get("aggregateType", "AVG").upper()
+
+    v_alias = _gen_alias()
+    v_label = _apply_cube_label_suffix(
+        value_resolved["fieldCode"], chart.get("valueLabel", "") or value_resolved["text"]
+    )
+    v_fc, v_dt = _fix_array_field_for_aggregate(value_resolved["fieldCode"], value_resolved["dataType"], agg_type)
+
+    query_defs = [_build_query_field_def(
+        v_alias, v_label, cube_code, v_fc, v_dt, agg_type,
+        classified_code=value_resolved["classifiedCode"],
+    )]
+    v_full = _build_full_field(
+        v_alias, v_label, cube_code, v_fc, v_dt, agg_type,
+        classified_code=value_resolved["classifiedCode"], field_id=value_resolved["id"],
+    )
+    all_full = [v_full]
+    aliases = [v_alias]
+
+    assit_fulls: list[dict[str, Any]] = []
+    assit_raw = chart.get("assitValueField")
+    if assit_raw:
+        if isinstance(assit_raw, list):
+            assit_raw = assit_raw[0] if assit_raw else None
+        if assit_raw:
+            assit_resolved = _resolve_field(assit_raw, cube_code)
+            a_alias = _gen_alias()
+            a_label = _apply_cube_label_suffix(
+                assit_resolved["fieldCode"], chart.get("assitLabel", "") or assit_resolved["text"]
+            )
+            a_fc, a_dt = _fix_array_field_for_aggregate(
+                assit_resolved["fieldCode"], assit_resolved["dataType"], agg_type
+            )
+            query_defs.append(_build_query_field_def(
+                a_alias, a_label, cube_code, a_fc, a_dt, agg_type,
+                classified_code=assit_resolved["classifiedCode"],
+            ))
+            a_full = _build_full_field(
+                a_alias, a_label, cube_code, a_fc, a_dt, agg_type,
+                classified_code=assit_resolved["classifiedCode"], field_id=assit_resolved["id"],
+            )
+            all_full.append(a_full)
+            aliases.append(a_alias)
+            assit_fulls.append(a_full)
+
+    return _wrap_dataset(
+        _DS_KEY_CHART, cube_code, cube_tenant_id,
+        query_defs, aliases, all_full,
+        extra={"valueField": [v_full], "assitValueField": assit_fulls},
+    )
+
+
+def _build_combo_data_model(
+    chart: dict[str, Any],
+    cube_code: str,
+    cube_tenant_id: str,
+) -> dict[str, Any]:
+    x_raw = chart.get("xField", "")
+    x_resolved = _resolve_field(x_raw, cube_code)
+
+    left_raw = chart.get("leftYFields", [])
+    if isinstance(left_raw, (str, dict)):
+        left_raw = [left_raw]
+    right_raw = chart.get("rightYFields", [])
+    if isinstance(right_raw, (str, dict)):
+        right_raw = [right_raw]
+
+    if not left_raw and not right_raw:
+        raise ValueError("combo 图表必须提供 leftYFields 或 rightYFields")
+
+    left_resolved = [_resolve_field(f, cube_code) for f in left_raw]
+    right_resolved = [_resolve_field(f, cube_code) for f in right_raw]
+
+    left_agg = chart.get("leftAggregateType", "SUM").upper()
+    right_agg = chart.get("rightAggregateType", "SUM").upper()
+
+    x_label = _apply_cube_label_suffix(
+        x_resolved["fieldCode"], chart.get("xLabel", "") or x_resolved["text"]
+    )
+    x_alias = _gen_alias()
+    x_time_gran = x_resolved["timeGranularityType"] or (
+        chart.get("timeGranularityType", "DAY") if _is_date_field(x_resolved["fieldCode"]) else None
+    )
+
+    query_defs = [_build_query_field_def(
+        x_alias, x_label, cube_code, x_resolved["fieldCode"], x_resolved["dataType"],
+        "NONE", x_time_gran, classified_code=x_resolved["classifiedCode"],
+    )]
+    x_full = _build_full_field(
+        x_alias, x_label, cube_code, x_resolved["fieldCode"], x_resolved["dataType"],
+        "NONE", x_time_gran, classified_code=x_resolved["classifiedCode"],
+        field_id=x_resolved["id"], time_format=x_resolved["timeFormat"],
+    )
+    all_full = [x_full]
+    all_aliases = [x_alias]
+
+    left_fulls: list[dict[str, Any]] = []
+    for lr in left_resolved:
+        alias = _gen_alias()
+        all_aliases.append(alias)
+        label = _apply_cube_label_suffix(lr["fieldCode"], lr["text"])
+        fc, dt = _fix_array_field_for_aggregate(lr["fieldCode"], lr["dataType"], left_agg)
+        query_defs.append(_build_query_field_def(
+            alias, label, cube_code, fc, dt, left_agg, classified_code=lr["classifiedCode"],
+        ))
+        full = _build_full_field(
+            alias, label, cube_code, fc, dt, left_agg,
+            classified_code=lr["classifiedCode"], field_id=lr["id"],
+        )
+        left_fulls.append(full)
+        all_full.append(full)
+
+    right_fulls: list[dict[str, Any]] = []
+    for rr in right_resolved:
+        alias = _gen_alias()
+        all_aliases.append(alias)
+        label = _apply_cube_label_suffix(rr["fieldCode"], rr["text"])
+        fc, dt = _fix_array_field_for_aggregate(rr["fieldCode"], rr["dataType"], right_agg)
+        query_defs.append(_build_query_field_def(
+            alias, label, cube_code, fc, dt, right_agg, classified_code=rr["classifiedCode"],
+        ))
+        full = _build_full_field(
+            alias, label, cube_code, fc, dt, right_agg,
+            classified_code=rr["classifiedCode"], field_id=rr["id"],
+        )
+        right_fulls.append(full)
+        all_full.append(full)
+
+    return _wrap_dataset(
+        _DS_KEY_DATASET, cube_code, cube_tenant_id,
+        query_defs, all_aliases, all_full,
+        extra={
+            "xField": [x_full],
+            "leftYFields": left_fulls,
+            "rightYFields": right_fulls,
+            "annotationField": [],
+        },
+    )
+
+
+def _build_pivot_data_model(
+    chart: dict[str, Any],
+    cube_code: str,
+    cube_tenant_id: str,
+) -> dict[str, Any]:
+    raw_columns = chart.get("columnList", []) or chart.get("columns", [])
+    if not raw_columns:
+        raise ValueError(
+            "pivot 图表必须提供 columnList（或 columns）。"
+            "请先通过 `dws yida form components` 获取源表字段定义。"
+        )
+
+    resolved_columns = [_resolve_field(col, cube_code) for col in raw_columns]
+
+    query_defs: list[dict[str, Any]] = []
+    aliases: list[str] = []
+    full_fields: list[dict[str, Any]] = []
+
+    for rc in resolved_columns:
+        label = _apply_cube_label_suffix(rc["fieldCode"], rc["text"])
+        alias = _gen_alias()
+        aliases.append(alias)
+        time_gran = rc["timeGranularityType"] or (
+            chart.get("timeGranularityType", "DAY") if _is_date_field(rc["fieldCode"]) else None
+        )
+        query_defs.append(_build_query_field_def(
+            alias, label, cube_code, rc["fieldCode"], rc["dataType"],
+            "NONE", time_gran, classified_code=rc["classifiedCode"],
+        ))
+        full = _build_full_field(
+            alias, label, cube_code, rc["fieldCode"], rc["dataType"],
+            "NONE", time_gran, classified_code=rc["classifiedCode"],
+            field_id=rc["id"], time_format=rc["timeFormat"],
+        )
+        full_fields.append(full)
+
+    return _wrap_dataset(
+        _DS_KEY_DATASET, cube_code, cube_tenant_id,
+        query_defs, aliases, full_fields,
+        extra={"columnList": full_fields},
+        extra_query={"filterMode": "PROFESSIONAL"},
+    )