@shwfed/config 1.1.5 → 2.0.1

package/dist/runtime/components/config/blocks/2026-05-17/com.shwfed.block.chart.line/runtime.vue

@@ -0,0 +1,233 @@
+<script setup>
+import { computed, onMounted, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Effect, Option } from "effect";
+import { Fetch } from "fx-fetch";
+import { CurveType } from "@unovis/ts";
+import { VisAxis, VisBulletLegend, VisCrosshair, VisLine, VisTooltip, VisXYContainer } from "@unovis/vue";
+import { Markdown } from "../../../../ui/markdown";
+import { cel } from "../../../../../utils/cel";
+import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { getLocalizedText } from "../../../../../share/locale";
+defineOptions({ name: "ShwfedBlockChartLineRuntime" });
+const block = defineModel("block", { type: null, ...{ required: true } });
+const { locale } = useI18n();
+const inheritedContext = injectCELContext();
+const mounted = ref(false);
+const dataValues = ref({});
+const fetchError = ref(null);
+const CURVE = {
+  linear: CurveType.Linear,
+  monotoneX: CurveType.MonotoneX,
+  natural: CurveType.Natural,
+  basis: CurveType.Basis,
+  cardinal: CurveType.Cardinal,
+  catmullRom: CurveType.CatmullRom,
+  step: CurveType.Step,
+  stepAfter: CurveType.StepAfter,
+  stepBefore: CurveType.StepBefore
+};
+const PALETTE = [
+  "#4e79a7",
+  "#f28e2b",
+  "#e15759",
+  "#76b7b2",
+  "#59a14f",
+  "#edc948",
+  "#b07aa1",
+  "#ff9da7",
+  "#9c755f",
+  "#bab0ac"
+];
+const lineColors = computed(
+  () => block.value.y.map(
+    (s, i) => s.color && s.color.length > 0 ? s.color : PALETTE[i % PALETTE.length]
+  )
+);
+const caption = computed(() => getLocalizedText(block.value.caption, locale.value) || "");
+function seriesLabel(s) {
+  return getLocalizedText(s.label, locale.value) || null;
+}
+function baseContext() {
+  return celBindings(inheritedContext);
+}
+async function fetchAll() {
+  const ctx = baseContext();
+  const out = {};
+  const failed = [];
+  for (const ds of block.value.dataSources) {
+    const program = Effect.gen(function* () {
+      let jsonOpt = Option.none();
+      if (ds.request) {
+        const builder = yield* cel(ds.request, ctx);
+        jsonOpt = Option.some(yield* builder.json());
+      }
+      return yield* cel(ds.data, { ...ctx, json: jsonOpt });
+    });
+    try {
+      out[ds.name] = await Effect.runPromise(Effect.provide(program, Fetch.layer));
+    } catch (e) {
+      console.warn("[shwfed-chart-line] data source failed", ds.name, e);
+      failed.push(ds.name);
+      out[ds.name] = [];
+    }
+  }
+  dataValues.value = out;
+  fetchError.value = failed.length > 0 ? `\u6570\u636E\u6E90\u52A0\u8F7D\u5931\u8D25\uFF1A${failed.join("\u3001")}` : null;
+}
+onMounted(() => {
+  mounted.value = true;
+  void fetchAll();
+});
+watch(
+  () => block.value.dataSources.map((d) => `${d.name}|${d.request ?? ""}|${d.data}`).join("\n"),
+  () => {
+    void fetchAll();
+  }
+);
+function isFiniteNum(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function toY(v) {
+  if (isFiniteNum(v)) return v;
+  if (typeof v === "string" && v.trim() !== "") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function evalList(expression, ctx) {
+  try {
+    const r = Effect.runSync(cel(expression, ctx));
+    return Array.isArray(r) ? r : [];
+  } catch {
+    return [];
+  }
+}
+const chartData = computed(() => {
+  const ctx = { ...baseContext(), ...dataValues.value };
+  const xRaw = evalList(block.value.x, ctx);
+  const yLists = block.value.y.map((s) => evalList(s.value, ctx));
+  const xMode = xRaw.length === 0 ? "ordinal" : xRaw.every((v) => v instanceof Date) ? "time" : xRaw.every((v) => isFiniteNum(v)) ? "number" : "ordinal";
+  const xLabels = /* @__PURE__ */ new Map();
+  const records = xRaw.map((xv, i) => {
+    const rec = { __x: i };
+    if (xMode === "time") rec.__x = xv.getTime();
+    else if (xMode === "number") rec.__x = xv;
+    else xLabels.set(i, xv === null || xv === void 0 ? "" : String(xv));
+    yLists.forEach((list, k) => {
+      rec[`y${k}`] = toY(list[i]);
+    });
+    return rec;
+  });
+  return { records, xMode, xLabels };
+});
+const xAccessor = (d) => d.__x;
+const yAccessors = computed(
+  () => block.value.y.map((_, k) => (d) => d[`y${k}`])
+);
+const legendItems = computed(() => {
+  const items = [];
+  block.value.y.forEach((s, i) => {
+    const label = seriesLabel(s);
+    if (label) items.push({ name: label, color: lineColors.value[i] });
+  });
+  return items;
+});
+const xTickFormat = computed(() => {
+  const mode = chartData.value.xMode;
+  if (mode === "ordinal") {
+    const labels = chartData.value.xLabels;
+    return (tick) => labels.get(tick) ?? "";
+  }
+  if (mode === "time") return (tick) => new Date(tick).toLocaleDateString();
+  return void 0;
+});
+const xTickValues = computed(() => {
+  if (chartData.value.xMode !== "ordinal") return void 0;
+  const keys = [...chartData.value.xLabels.keys()];
+  if (keys.length <= 12) return keys;
+  const stride = Math.ceil(keys.length / 10);
+  return keys.filter((_, i) => i % stride === 0);
+});
+function formatNumber(n) {
+  return Number.isInteger(n) ? String(n) : n.toFixed(2);
+}
+function escapeHtml(s) {
+  return s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c] ?? c);
+}
+function crosshairTemplate(d) {
+  const mode = chartData.value.xMode;
+  const xLabel = mode === "ordinal" ? chartData.value.xLabels.get(d.__x) ?? "" : mode === "time" ? new Date(d.__x).toLocaleDateString() : String(d.__x);
+  const rows = [];
+  block.value.y.forEach((s, k) => {
+    const label = seriesLabel(s);
+    if (!label) return;
+    const v = d[`y${k}`];
+    rows.push(
+      `<div style="display:flex;align-items:center;gap:6px;padding:1px 0"><span style="width:8px;height:8px;border-radius:9999px;background:${lineColors.value[k]}"></span><span style="color:#3f3f46">${escapeHtml(label)}</span><span style="margin-left:auto;font-variant-numeric:tabular-nums;color:#18181b">${v === void 0 ? "\u2014" : formatNumber(v)}</span></div>`
+    );
+  });
+  const lines = rows.join("");
+  return `<div style="font-size:12px;min-width:160px"><div style="font-weight:600;color:#18181b;margin-bottom:4px">${escapeHtml(xLabel)}</div>${lines}</div>`;
+}
+const placeholder = computed(() => {
+  if (fetchError.value) return fetchError.value;
+  if (chartData.value.records.length === 0) return "\u6682\u65E0\u6570\u636E";
+  return null;
+});
+</script>
+
+<template>
+  <div class="flex h-full min-h-[200px] w-full flex-col gap-2">
+    <div
+      v-if="placeholder"
+      class="flex flex-1 items-center justify-center text-sm text-zinc-400"
+    >
+      {{ placeholder }}
+    </div>
+
+    <template v-else-if="mounted">
+      <VisXYContainer
+        :data="chartData.records"
+        :margin="{ top: 8, right: 16, bottom: 4, left: 8 }"
+        class="min-h-0 flex-1"
+      >
+        <VisLine
+          :x="xAccessor"
+          :y="yAccessors"
+          :color="lineColors"
+          :curve-type="CURVE[block.curveType]"
+          :line-width="block.lineWidth"
+        />
+        <VisAxis
+          type="x"
+          :tick-format="xTickFormat"
+          :tick-values="xTickValues"
+          :tick-text-hide-overlapping="true"
+          :grid-line="false"
+        />
+        <VisAxis type="y" />
+        <VisCrosshair
+          :x="xAccessor"
+          :y="yAccessors"
+          :color="lineColors"
+          :template="crosshairTemplate"
+        />
+        <VisTooltip />
+      </VisXYContainer>
+
+      <VisBulletLegend
+        v-if="legendItems.length > 0"
+        :items="legendItems"
+        class="mx-auto w-fit shrink-0 text-xs"
+      />
+      <Markdown
+        v-if="caption"
+        :source="caption"
+        block
+        class="prose prose-sm prose-zinc max-w-none shrink-0 text-center"
+      />
+    </template>
+  </div>
+</template>

package/dist/runtime/components/config/blocks/2026-05-17/com.shwfed.block.chart.line/runtime.vue.d.ts

@@ -0,0 +1,77 @@
+import type { Value } from './schema.js';
+type __VLS_ModelProps = {
+    'block': Value;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:block": (value: {
+        readonly type: "com.shwfed.block.chart.line";
+        readonly id: string;
+        readonly caption?: readonly [{
+            readonly locale: "zh";
+            readonly message: string;
+        }, ...{
+            readonly locale: "en" | "ja" | "ko";
+            readonly message: string;
+        }[]] | undefined;
+        readonly x: string;
+        readonly y: readonly {
+            readonly label?: readonly [{
+                readonly locale: "zh";
+                readonly message: string;
+            }, ...{
+                readonly locale: "en" | "ja" | "ko";
+                readonly message: string;
+            }[]] | undefined;
+            readonly id: string;
+            readonly color?: string | undefined;
+            readonly value: string;
+        }[];
+        readonly displayName?: string | undefined;
+        readonly compatibilityDate: "2026-05-17";
+        readonly dataSources: readonly {
+            readonly name: string;
+            readonly data: string;
+            readonly id: string;
+            readonly request?: string | undefined;
+        }[];
+        readonly curveType: "linear" | "step" | "monotoneX" | "natural" | "basis" | "cardinal" | "catmullRom" | "stepAfter" | "stepBefore";
+        readonly lineWidth: number;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
+    "onUpdate:block"?: ((value: {
+        readonly type: "com.shwfed.block.chart.line";
+        readonly id: string;
+        readonly caption?: readonly [{
+            readonly locale: "zh";
+            readonly message: string;
+        }, ...{
+            readonly locale: "en" | "ja" | "ko";
+            readonly message: string;
+        }[]] | undefined;
+        readonly x: string;
+        readonly y: readonly {
+            readonly label?: readonly [{
+                readonly locale: "zh";
+                readonly message: string;
+            }, ...{
+                readonly locale: "en" | "ja" | "ko";
+                readonly message: string;
+            }[]] | undefined;
+            readonly id: string;
+            readonly color?: string | undefined;
+            readonly value: string;
+        }[];
+        readonly displayName?: string | undefined;
+        readonly compatibilityDate: "2026-05-17";
+        readonly dataSources: readonly {
+            readonly name: string;
+            readonly data: string;
+            readonly id: string;
+            readonly request?: string | undefined;
+        }[];
+        readonly curveType: "linear" | "step" | "monotoneX" | "natural" | "basis" | "cardinal" | "catmullRom" | "stepAfter" | "stepBefore";
+        readonly lineWidth: number;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/config/blocks/2026-05-17/com.shwfed.block.chart.line/schema.d.ts

@@ -0,0 +1,134 @@
+import { Schema } from 'effect';
+import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+export { getStructFieldDescription, getStructFieldTitle } from '../../../../table/utils/schema-meta.js';
+type AnySchema = Schema.Schema<any, any, never>;
+type Configure = (env: Environment) => void;
+export declare const type: "com.shwfed.block.chart.line";
+export declare const compatibilityDate: "2026-05-17";
+export declare const metadata: {
+    readonly name: "折线图";
+    readonly icon: "fluent:data-line-20-regular";
+    readonly w: {
+        readonly initial: 20;
+        readonly min: 8;
+        readonly max: number;
+    };
+    readonly h: {
+        readonly initial: 9;
+        readonly min: 5;
+        readonly max: number;
+    };
+};
+export declare const CurveType: Schema.Literal<["linear", "monotoneX", "natural", "basis", "cardinal", "catmullRom", "step", "stepAfter", "stepBefore"]>;
+/**
+ * A named data source. Exported so the config editor can read field
+ * `title` / `description` annotations without rebuilding the whole schema.
+ */
+export declare function dataSourceSchema(configure: Configure): Schema.Struct<{
+    id: Schema.refine<string, typeof Schema.String>;
+    name: Schema.refine<string, typeof Schema.String>;
+    request: Schema.optional<Schema.Schema<string, string, never>>;
+    data: Schema.Schema<string, string, never>;
+}>;
+/**
+ * One Y series. Exported so the config editor can read field
+ * `title` / `description` annotations off it.
+ */
+export declare function ySeriesSchema(configure: Configure): Schema.Struct<{
+    id: Schema.refine<string, typeof Schema.String>;
+    value: Schema.Schema<string, string, never>;
+    label: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    color: Schema.optional<typeof Schema.String>;
+}>;
+export declare function schema(configure: Configure, _blockRef?: AnySchema): Schema.refine<{
+    readonly type: "com.shwfed.block.chart.line";
+    readonly id: string;
+    readonly caption?: readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]] | undefined;
+    readonly x: string;
+    readonly y: readonly {
+        readonly label?: readonly [{
+            readonly locale: "zh";
+            readonly message: string;
+        }, ...{
+            readonly locale: "en" | "ja" | "ko";
+            readonly message: string;
+        }[]] | undefined;
+        readonly id: string;
+        readonly color?: string | undefined;
+        readonly value: string;
+    }[];
+    readonly displayName?: string | undefined;
+    readonly compatibilityDate: "2026-05-17";
+    readonly dataSources: readonly {
+        readonly name: string;
+        readonly data: string;
+        readonly id: string;
+        readonly request?: string | undefined;
+    }[];
+    readonly curveType: "linear" | "step" | "monotoneX" | "natural" | "basis" | "cardinal" | "catmullRom" | "stepAfter" | "stepBefore";
+    readonly lineWidth: number;
+}, Schema.Struct<{
+    id: Schema.refine<string, typeof Schema.String>;
+    type: Schema.tag<"com.shwfed.block.chart.line">;
+    compatibilityDate: Schema.tag<"2026-05-17">;
+    displayName: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    caption: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    dataSources: Schema.Array$<Schema.Struct<{
+        id: Schema.refine<string, typeof Schema.String>;
+        name: Schema.refine<string, typeof Schema.String>;
+        request: Schema.optional<Schema.Schema<string, string, never>>;
+        data: Schema.Schema<string, string, never>;
+    }>>;
+    x: Schema.Schema<string, string, never>;
+    y: Schema.refine<readonly {
+        readonly label?: readonly [{
+            readonly locale: "zh";
+            readonly message: string;
+        }, ...{
+            readonly locale: "en" | "ja" | "ko";
+            readonly message: string;
+        }[]] | undefined;
+        readonly id: string;
+        readonly color?: string | undefined;
+        readonly value: string;
+    }[], Schema.Array$<Schema.Struct<{
+        id: Schema.refine<string, typeof Schema.String>;
+        value: Schema.Schema<string, string, never>;
+        label: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+            locale: Schema.Literal<["zh"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>], [Schema.Struct<{
+            locale: Schema.Literal<["ja", "en", "ko"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>]>>;
+        color: Schema.optional<typeof Schema.String>;
+    }>>>;
+    curveType: Schema.optionalWith<Schema.Literal<["linear", "monotoneX", "natural", "basis", "cardinal", "catmullRom", "step", "stepAfter", "stepBefore"]>, {
+        default: () => "monotoneX";
+    }>;
+    lineWidth: Schema.optionalWith<Schema.filter<typeof Schema.Number>, {
+        default: () => number;
+    }>;
+}>>;
+export declare function defaultBody(): Record<string, unknown>;
+export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
+export type YSeriesValue = Value['y'][number];
+export type DataSourceValue = Value['dataSources'][number];

package/dist/runtime/components/config/blocks/2026-05-17/com.shwfed.block.chart.line/schema.js

@@ -0,0 +1,142 @@
+import { Schema } from "effect";
+import { Expression } from "../../../../../share/expression.js";
+import { Locale } from "../../../../../share/locale.js";
+export { getStructFieldDescription, getStructFieldTitle } from "../../../../table/utils/schema-meta.js";
+export const type = "com.shwfed.block.chart.line";
+export const compatibilityDate = "2026-05-17";
+export const metadata = {
+  name: "\u6298\u7EBF\u56FE",
+  icon: "fluent:data-line-20-regular",
+  w: { initial: 20, min: 8, max: Infinity },
+  h: { initial: 9, min: 5, max: Infinity }
+};
+export const CurveType = Schema.Literal(
+  "linear",
+  "monotoneX",
+  "natural",
+  "basis",
+  "cardinal",
+  "catmullRom",
+  "step",
+  "stepAfter",
+  "stepBefore"
+);
+const isListType = (t) => t === "dyn" || t.startsWith("list") || t.startsWith("optional");
+function listExpression(configure) {
+  return Expression({
+    configure,
+    resultType: isListType,
+    unlistedVariablesAreDyn: true
+  });
+}
+export function dataSourceSchema(configure) {
+  const CelRequest = Expression({
+    configure: (env) => {
+      configure(env);
+    },
+    resultType: "HttpRequest"
+  });
+  const CelData = Expression({
+    configure: (env) => {
+      configure(env);
+      env.registerVariable("json", "optional<dyn>", {
+        description: "HTTP \u54CD\u5E94\u4F53\uFF08\u5DF2\u89E3\u6790 JSON\uFF09\uFF1B\u672A\u914D\u7F6E request \u65F6\u4E3A none"
+      });
+    },
+    resultType: isListType
+  });
+  return Schema.Struct({
+    id: Schema.UUID.annotations({ description: "\u6570\u636E\u6E90\u552F\u4E00\u6807\u8BC6" }),
+    name: Schema.String.pipe(Schema.pattern(/^[a-z_]\w*$/i)).annotations({
+      title: "\u53D8\u91CF\u540D",
+      description: "\u5728 X / Y \u8868\u8FBE\u5F0F\u4E2D\u5F15\u7528\u8BE5\u6570\u636E\u6E90\u7684 CEL \u6807\u8BC6\u7B26\uFF08\u5B57\u6BCD\u6216\u4E0B\u5212\u7EBF\u5F00\u5934\uFF0C\u4EC5\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\uFF09"
+    }),
+    request: Schema.optional(CelRequest).annotations({
+      title: "\u8BF7\u6C42",
+      description: "\u53EF\u9009\u7684 HTTP \u8BF7\u6C42\u8868\u8FBE\u5F0F\uFF1B\u672A\u914D\u7F6E\u65F6\u6570\u636E\u76F4\u63A5\u4ECE `\u6570\u636E` \u8868\u8FBE\u5F0F\u8BFB\u53D6\uFF08\u901A\u5E38\u5F15\u7528\u4E0A\u4E0B\u6587\u53D8\u91CF\uFF09"
+    }),
+    data: CelData.annotations({
+      title: "\u6570\u636E",
+      description: "\u8FD4\u56DE\u4E00\u4E2A\u5217\u8868\uFF08`list<dyn>`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u914D\u7F6E\u4E86 `\u8BF7\u6C42` \u65F6\u53EF\u901A\u8FC7 `json` \u5F15\u7528\u54CD\u5E94\u4F53\u3002\u7ED3\u679C\u4EE5\u4E0A\u9762\u7684\u53D8\u91CF\u540D\u66B4\u9732\u7ED9 X / Y"
+    })
+  }).annotations({
+    title: "\u6570\u636E\u6E90",
+    description: "\u4E00\u4E2A\u547D\u540D\u6570\u636E\u6E90\uFF1B\u5176\u7ED3\u679C\u5217\u8868\u4EE5\u53D8\u91CF\u540D\u63D0\u4F9B\u7ED9 X / Y \u8868\u8FBE\u5F0F"
+  });
+}
+export function ySeriesSchema(configure) {
+  return Schema.Struct({
+    id: Schema.UUID.annotations({ description: "Y \u7CFB\u5217\u552F\u4E00\u6807\u8BC6" }),
+    value: listExpression(configure).annotations({
+      title: "Y \u8868\u8FBE\u5F0F",
+      description: "\u8FD4\u56DE\u4E00\u4E2A\u5217\u8868\u4F5C\u4E3A\u8BE5\u7CFB\u5217\u7684 Y \u503C\uFF0C\u4E0E X \u6309\u4E0B\u6807\u5BF9\u9F50\uFF1B\u53EF\u5F15\u7528\u6570\u636E\u6E90\u53D8\u91CF\uFF0C\u5982 `source1.map(r, r.value)`"
+    }),
+    label: Schema.optional(Locale).annotations({
+      title: "\u6807\u7B7E",
+      description: "\u56FE\u4F8B\u4E0E\u63D0\u793A\u6846\u4E2D\u663E\u793A\u7684\u7CFB\u5217\u540D\uFF1B\u7559\u7A7A\u5219\u7528\u8868\u8FBE\u5F0F\u539F\u6587"
+    }),
+    color: Schema.optional(Schema.String).annotations({
+      title: "\u989C\u8272",
+      description: "\u7EBF\u6761\u989C\u8272\uFF08CSS \u989C\u8272\u503C\uFF09\uFF1B\u7559\u7A7A\u5219\u6309\u8C03\u8272\u677F\u81EA\u52A8\u53D6\u8272"
+    })
+  }).annotations({ title: "Y \u7CFB\u5217", description: "\u4E00\u4E2A Y \u7CFB\u5217\u5BF9\u5E94\u4E00\u6761\u6298\u7EBF" });
+}
+export function schema(configure, _blockRef) {
+  return Schema.Struct({
+    id: Schema.UUID.annotations({ description: "\u5757\u552F\u4E00\u6807\u8BC6" }),
+    type: Schema.tag(type),
+    compatibilityDate: Schema.tag(compatibilityDate),
+    displayName: Schema.optional(Schema.String.annotations({
+      title: "\u5185\u90E8\u540D\u79F0",
+      description: "\u4EC5\u5728\u7F16\u8F91\u5668\u5185\u53EF\u89C1\u7684\u5757\u540D\uFF0C\u7528\u4E8E\u5728\u4FA7\u8FB9\u680F\u548C\u5E03\u5C40\u7F16\u8F91\u5668\u4E2D\u8BC6\u522B\u5757\uFF1B\u8FD0\u884C\u65F6\u4E0D\u5C55\u793A"
+    })),
+    caption: Schema.optional(Locale).annotations({
+      title: "\u8BF4\u660E\u6587\u5B57",
+      description: "\u663E\u793A\u5728\u56FE\u8868\u4E0B\u65B9\u7684\u672C\u5730\u5316\u8BF4\u660E\u6587\u5B57\uFF1B\u7559\u7A7A\u5219\u4E0D\u663E\u793A"
+    }),
+    dataSources: Schema.Array(dataSourceSchema(configure)).annotations({
+      title: "\u6570\u636E\u6E90",
+      description: "\u4E00\u4E2A\u6216\u591A\u4E2A\u547D\u540D\u6570\u636E\u6E90\uFF1B\u6BCF\u4E2A\u6570\u636E\u6E90\u7684\u7ED3\u679C\u5217\u8868\u4EE5\u5176\u53D8\u91CF\u540D\u63D0\u4F9B\u7ED9 X / Y \u8868\u8FBE\u5F0F"
+    }),
+    x: listExpression(configure).annotations({
+      title: "X",
+      description: '\u8FD4\u56DE\u4E00\u4E2A\u5217\u8868\u4F5C\u4E3A X \u503C\uFF1B\u53EF\u7531 `range` \u751F\u6210\uFF08\u5982 `range(date("2024-01-01"), date("2024-12-01"), "month")`\uFF09\uFF0C\u6216\u5BF9\u6570\u636E\u6E90\u505A `.map`\uFF1B\u5B57\u7B26\u4E32\u5217\u8868\u89C6\u4F5C\u5206\u7C7B\u8F74\uFF0C\u6570\u5B57 / \u65E5\u671F\u5217\u8868\u89C6\u4F5C\u8FDE\u7EED\u8F74'
+    }),
+    y: Schema.Array(ySeriesSchema(configure)).pipe(Schema.minItems(1)).annotations({
+      title: "Y",
+      description: "\u6BCF\u4E2A\u7CFB\u5217\u753B\u4E00\u6761\u7EBF\uFF0C\u8FD4\u56DE\u7684\u5217\u8868\u4E0E X \u6309\u4E0B\u6807\u5BF9\u9F50\uFF1B\u81F3\u5C11\u914D\u7F6E\u4E00\u6761"
+    }),
+    curveType: Schema.optionalWith(CurveType, { default: () => "monotoneX" }).annotations({
+      title: "\u66F2\u7EBF\u7C7B\u578B",
+      description: "\u6298\u7EBF\u5728\u76F8\u90BB\u6570\u636E\u70B9\u4E4B\u95F4\u7684\u63D2\u503C\u65B9\u5F0F\uFF08\u5BF9\u5E94 unovis `CurveType`\uFF09"
+    }),
+    lineWidth: Schema.optionalWith(
+      Schema.Number.pipe(Schema.positive()),
+      { default: () => 2 }
+    ).annotations({
+      title: "\u7EBF\u5BBD",
+      description: "\u6298\u7EBF\u5BBD\u5EA6\uFF08\u50CF\u7D20\uFF09"
+    })
+  }).pipe(
+    Schema.filter((value) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (const ds of value.dataSources) {
+        if (seen.has(ds.name)) return `\u6570\u636E\u6E90\u53D8\u91CF\u540D\u91CD\u590D\uFF1A${ds.name}`;
+        seen.add(ds.name);
+      }
+      return true;
+    })
+  ).annotations({
+    title: "\u6298\u7EBF\u56FE\u5757",
+    description: "\u4ECE\u547D\u540D\u6570\u636E\u6E90\u53D6\u6570\uFF0C\u628A X / Y \u5217\u8868\u6E32\u67D3\u4E3A\u6298\u7EBF\u56FE"
+  });
+}
+export function defaultBody() {
+  return {
+    dataSources: [],
+    x: "[]",
+    y: [{ id: crypto.randomUUID(), value: "[]" }],
+    curveType: "monotoneX",
+    lineWidth: 2
+  };
+}

package/dist/runtime/components/config/index.vue

@@ -1,6 +1,6 @@
 <script setup>
 import { computed, ref, watch } from "vue";
-import { injectCELContext } from "../../plugins/cel/context";
+import { injectCELContext } from "../../utils/cel-context";
 import SlotRenderer from "../../share/slot-renderer.vue";
 import ShwfedModal from "../modal.vue";
 import EditorBody from "./config.vue";

package/dist/runtime/components/config/use-editor.js

@@ -132,7 +132,9 @@ export function useSlotEditor(slot, options = {}) {
   }
   function getBlockLabel(b) {
     const entry = findBlock(b.type, b.compatibilityDate);
-    return entry?.metadata.name ?? "\u672A\u547D\u540D\u5757";
+    const typeName = entry?.metadata.name ?? "\u672A\u547D\u540D\u5757";
+    const displayName = b.displayName;
+    return typeof displayName === "string" && displayName.length > 0 ? displayName : typeName;
   }
   function findBlockMeta(type, compatibilityDate) {
     return findBlock(type, compatibilityDate);
@@ -251,8 +253,7 @@ export function useConfigEditor(model, options = {}) {
     const base = stack.value.map((entry, i) => {
       if (entry.kind === "layout") return { kind: "layout", label: "\u5E03\u5C40", index: i };
       const b = topSlotEditor.blocks.value.find((x) => x.id === entry.blockId);
-      const meta = b ? findBlock(b.type, b.compatibilityDate)?.metadata : void 0;
-      const baseLabel = meta?.name ?? "\u5757";
+      const baseLabel = b ? topSlotEditor.getBlockLabel(b) : "\u5757";
       const label = i === lastBlockStackIndex ? `${baseLabel}${suffixDecoration}` : baseLabel;
       return {
         kind: "block",

package/dist/runtime/components/form/DerivedValueEditor.d.vue.ts

@@ -0,0 +1,19 @@
+import { type DerivedMode } from './utils/common.js';
+type DerivedConfig = {
+    mode: DerivedMode;
+    expression: string;
+};
+type __VLS_Props = {
+    /** The field's current `derived` config, or `undefined` when it has none. */
+    modelValue?: DerivedConfig;
+    /** Constrains the expression's CEL return type — the field's value type. */
+    resultType?: string | string[];
+    placeholder?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: DerivedConfig | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: DerivedConfig | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;