lujingze/SystemSimulationApp
1
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

修复机械事件力曲线并对齐气动孔口端口显示

Browse Source
This commit is contained in:
huojiarong committed 2026-08-20 05:59:04 +00:00
1 parent e18399c022
commit 408b4ecb22
11 files changed
+697 -43
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

frontend/src/App.tsx
+7 -1
View File
@@ -142,6 +142,7 @@ import {
isParameterExpressionValue,
isScientificNotationValue,
} from "./parameterExpression";
import { migratedPnvo001Mirrored } from "./pnvoPortDisplayMigration";
import {
WorkspaceViewTabs,
type WorkspaceView,
@@ -9473,7 +9474,12 @@ function normalizeLoadedNode(
parameterUnits,
parameterScientificNotation,
rotation: normalizeNodeRotation(node.data.rotation),
mirrored: Boolean(node.data.mirrored),
mirrored: migratedPnvo001Mirrored(
definition?.modelType ?? node.data.modelType,
node.data.ports,
definition?.ports,
Boolean(node.data.mirrored),
),
},
};
}
frontend/src/SimulationResultsView.tsx
+71 -30
View File
@@ -50,6 +50,11 @@ import {
orthogonalEdgePoints,
type EdgeRouteData,
} from "./edgeRouting";
import {
continuousMechanicalForceChartValues,
resultStateTransitionSampleIndices,
segmentedChartPath,
} from "./resultEventSeries";
type ResultPortDefinition = {
name: string;
@@ -136,6 +141,11 @@ type ResultPayload = {
final: Record<string, number>;
series: Record<string, number[]>;
diagnostics: {
integration?: {
segments?: Array<{
stateTransitionTimes?: number[];
}>;
};
pressureFlow: {
solveCount: number;
maxScaledResidual: number;
@@ -383,6 +393,14 @@ export function SimulationResultsView({
}: SimulationResultsViewProps) {
const reactFlow = useReactFlow();
const resultStatus = simulationResultStatus(snapshot.result);
const stateTransitionSampleIndices = useMemo(
() =>
resultStateTransitionSampleIndices(
snapshot.result.series.time ?? [],
snapshot.result.diagnostics,
),
[snapshot.result.diagnostics, snapshot.result.series.time],
);
const [selectedNodeId, setSelectedNodeId] = useState<string | null>(
snapshot.project.nodes[0]?.id ?? null,
);
@@ -1613,9 +1631,16 @@ export function SimulationResultsView({
variable,
chartWindow.unit,
);
const displayValues = (
snapshot.result.series[chartWindow.variableKey] ?? []
).map(selectedUnit.fromBase);
const chartTime = snapshot.result.series.time ?? [];
const primaryChartValues = continuousMechanicalForceChartValues(
variable,
component,
snapshot.result.series[chartWindow.variableKey] ?? [],
stateTransitionSampleIndices,
);
const displayValues = primaryChartValues.values.map(
selectedUnit.fromBase,
);
const combinedVariables = windowVariables.filter(
(item) => isMixed || item.unit === variable.unit,
);
@@ -1632,6 +1657,13 @@ export function SimulationResultsView({
chartWindow.variableUnits[item.key] ?? item.unit,
)
: selectedUnit;
const itemChartValues =
continuousMechanicalForceChartValues(
item,
itemComponent,
snapshot.result.series[item.key] ?? [],
stateTransitionSampleIndices,
);
return {
key: item.key,
label: resultVariableTitle(
@@ -1640,12 +1672,18 @@ export function SimulationResultsView({
),
color: colorForVariable(item.key),
unit: itemUnit.label,
values: (snapshot.result.series[item.key] ?? []).map(
itemUnit.fromBase,
),
values: itemChartValues.values.map(itemUnit.fromBase),
separatedEventSampleCount:
itemChartValues.separatedEventSampleCount,
};
});
const chartTime = snapshot.result.series.time ?? [];
const separatedEventSampleCount = isCombined
? multiSeries.reduce(
(count, item) =>
count + item.separatedEventSampleCount,
0,
)
: primaryChartValues.separatedEventSampleCount;
const visibilitySeries = isCombined
? multiSeries
: [
@@ -1671,6 +1709,7 @@ export function SimulationResultsView({
}`}
data-chart-kind={chartWindow.kind}
data-pending="false"
data-separated-event-samples={separatedEventSampleCount}
key={chartWindow.id}
onDragLeave={(event) => {
if (
@@ -1727,6 +1766,9 @@ export function SimulationResultsView({
{isCombined
? `${visibleCombinedVariables.length}/${combinedVariables.length} 条显示 · ${isMixed ? "上下同步图" : variable.unit || "无量纲"}`
: componentName}
{separatedEventSampleCount > 0
? ` · 已隐藏 ${separatedEventSampleCount} 个孤立事件力尖峰`
: ""}
</span>
</div>
<div className="result-chart-window-actions">
@@ -2026,7 +2068,7 @@ export function SimulationResultsView({
}
onZoomPrevious={() => undoChartWindowZoom(chartWindow.id)}
series={multiSeries}
time={snapshot.result.series.time ?? []}
time={chartTime}
viewport={chartWindow.viewport}
zoomEnabled={chartWindow.zoomEnabled}
/>
@@ -2038,7 +2080,7 @@ export function SimulationResultsView({
}
onZoomPrevious={() => undoChartWindowZoom(chartWindow.id)}
series={multiSeries}
time={snapshot.result.series.time ?? []}
time={chartTime}
title="多曲线对比"
unit={selectedUnit.label}
viewport={chartWindow.viewport}
@@ -2052,7 +2094,7 @@ export function SimulationResultsView({
updateChartWindowViewport(chartWindow.id, viewport)
}
onZoomPrevious={() => undoChartWindowZoom(chartWindow.id)}
time={snapshot.result.series.time ?? []}
time={chartTime}
title={chartTitle}
unit={selectedUnit.label}
values={displayValues}
@@ -2268,6 +2310,7 @@ type MultiCurveSeries = {
color: string;
unit: string;
values: number[];
separatedEventSampleCount: number;
};
type ChartVisibilitySeries = {
@@ -3598,12 +3641,12 @@ function MultiCurvePlot({
/>
<g clipPath={`url(#${clipPathId})`} data-chart-clipped-series="true">
{plottedSeries.map((curve) => {
const path = curve.samples
.map(
(sample, index) =>
`${index === 0 ? "M" : "L"} ${xPosition(sample.x).toFixed(2)} ${yPosition(sample.y).toFixed(2)}`,
)
.join(" ");
const path = segmentedChartPath(
time,
curve.values,
xPosition,
yPosition,
);
return (
<path
d={path}
@@ -4157,12 +4200,12 @@ function StackedCurvePlot({
</defs>
{plotBands.map((band) => {
const isLast = band.index === plotBands.length - 1;
const path = band.curve.samples
.map(
(sample, sampleIndex) =>
`${sampleIndex === 0 ? "M" : "L"} ${xPosition(sample.x).toFixed(2)} ${band.yPosition(sample.y).toFixed(2)}`,
)
.join(" ");
const path = segmentedChartPath(
time,
band.curve.values,
xPosition,
band.yPosition,
);
return (
<g className="result-chart-stack-band" key={band.curve.key}>
{band.index > 0 ? (
@@ -4614,14 +4657,12 @@ function CurvePlot({
margin.top + (1 - (value - yMin) / yRange) * plotHeight;
const xTicks = chartTicks(xMin, xMax, 5);
const yTicks = chartTicks(yMin, yMax, 5);
const path = samples
.map(
(sample, index) =>
`${index === 0 ? "M" : "L"} ${xPosition(sample.x).toFixed(2)} ${yPosition(
sample.y,
).toFixed(2)}`,
)
.join(" ");
const path = segmentedChartPath(
time,
values,
xPosition,
yPosition,
);
const requestedCursorIndex =
cursorIndex === null
? Math.floor(samples.length / 2)
frontend/src/pnvoPortDisplayMigration.ts
+39
View File
@@ -0,0 +1,39 @@
type PortSideSnapshot = {
name: string;
side: string;
};
const PNVO001_MODEL_TYPES = new Set([
"amesim_pnvo001_fixed",
"amesim_pnvo001",
]);
function portUsesSide(
ports: readonly PortSideSnapshot[],
portName: string,
side: string,
) {
return ports.some((port) => port.name === portName && port.side === side);
}
export function migratedPnvo001Mirrored(
modelType: string,
savedPorts: readonly PortSideSnapshot[],
currentPorts: readonly PortSideSnapshot[] | undefined,
mirrored: boolean,
) {
if (!PNVO001_MODEL_TYPES.has(modelType) || !currentPorts) {
return mirrored;
}
const savedUsesLegacySides =
portUsesSide(savedPorts, "port_2", "left") &&
portUsesSide(savedPorts, "port_3", "right");
const catalogUsesAmesimSides =
portUsesSide(currentPorts, "port_2", "right") &&
portUsesSide(currentPorts, "port_3", "left");
return savedUsesLegacySides && catalogUsesAmesimSides
? !mirrored
: mirrored;
}
frontend/src/resultEventSeries.ts
+190
View File
@@ -0,0 +1,190 @@
export type StateTransitionDiagnostics = {
integration?: {
segments?: Array<{
stateTransitionTimes?: number[];
}>;
};
};
type EventSeriesVariable = {
scope: "component" | "port";
portName: string | null;
quantity: string;
category: string;
};
type EventSeriesComponent = {
data: {
ports: Array<{
name: string;
domain: string;
}>;
};
};
const ISOLATED_EVENT_FORCE_RATIO = 100;
export function resultStateTransitionSampleIndices(
time: number[],
diagnostics: StateTransitionDiagnostics,
) {
const indices = new Set<number>();
for (const segment of diagnostics.integration?.segments ?? []) {
for (const eventTime of segment.stateTransitionTimes ?? []) {
if (!Number.isFinite(eventTime)) {
continue;
}
let index = time.indexOf(eventTime);
if (index < 0) {
const tolerance = 1e-12 * Math.max(Math.abs(eventTime), 1);
index = time.findIndex(
(sampleTime) => Math.abs(sampleTime - eventTime) <= tolerance,
);
}
if (index >= 0) {
indices.add(index);
}
}
}
return indices;
}
export function continuousMechanicalForceChartValues(
variable: EventSeriesVariable,
component: EventSeriesComponent | undefined,
values: number[],
stateTransitionSampleIndices: ReadonlySet<number>,
) {
const componentHasMechanicalPort = Boolean(
component?.data.ports.some((port) => port.domain === "mechanical"),
);
const forceBelongsToMechanicalDomain =
variable.scope === "component"
? variable.category === "derived" && componentHasMechanicalPort
: variable.portName !== null &&
Boolean(
component?.data.ports.some(
(port) =>
port.name === variable.portName &&
port.domain === "mechanical",
),
);
if (variable.quantity !== "force" || !forceBelongsToMechanicalDomain) {
return { values, separatedEventSampleCount: 0 };
}
const isolatedEventIndices: number[] = [];
for (const index of stateTransitionSampleIndices) {
if (
index < 0 ||
index >= values.length ||
!isolatedEventForceSample(
values,
index,
stateTransitionSampleIndices,
)
) {
continue;
}
isolatedEventIndices.push(index);
}
if (isolatedEventIndices.length === 0) {
return { values, separatedEventSampleCount: 0 };
}
const displayValues = values.slice();
for (const index of isolatedEventIndices) {
displayValues[index] = Number.NaN;
}
return {
values: displayValues,
separatedEventSampleCount: isolatedEventIndices.length,
};
}
function isolatedEventForceSample(
values: number[],
index: number,
stateTransitionSampleIndices: ReadonlySet<number>,
) {
const value = Number(values[index]);
if (!Number.isFinite(value)) {
return false;
}
const previous = finiteNonEventNeighbor(
values,
index - 1,
-1,
stateTransitionSampleIndices,
);
const next = finiteNonEventNeighbor(
values,
index + 1,
1,
stateTransitionSampleIndices,
);
if (previous === null || next === null) {
return false;
}
const localScale = Math.max(
Math.abs(previous),
Math.abs(next),
Math.abs(next - previous),
1e-9,
);
const localEstimate = (previous + next) / 2;
return (
Math.abs(value) > ISOLATED_EVENT_FORCE_RATIO * localScale &&
Math.abs(value - localEstimate) >
ISOLATED_EVENT_FORCE_RATIO * localScale
);
}
function finiteNonEventNeighbor(
values: number[],
startIndex: number,
direction: -1 | 1,
stateTransitionSampleIndices: ReadonlySet<number>,
) {
for (
let index = startIndex;
index >= 0 && index < values.length;
index += direction
) {
if (stateTransitionSampleIndices.has(index)) {
continue;
}
const value = Number(values[index]);
if (Number.isFinite(value)) {
return value;
}
}
return null;
}
export function segmentedChartPath(
time: number[],
values: number[],
xPosition: (value: number) => number,
yPosition: (value: number) => number,
) {
const commands: string[] = [];
let continuesSegment = false;
for (let index = 0; index < time.length; index += 1) {
const x = Number(time[index]);
const y = Number(values[index]);
if (!Number.isFinite(x)) {
continuesSegment = false;
continue;
}
if (!Number.isFinite(y)) {
continue;
}
commands.push(
`${continuesSegment ? "L" : "M"} ${xPosition(x).toFixed(2)} ${yPosition(y).toFixed(2)}`,
);
continuesSegment = true;
}
return commands.join(" ");
}
frontend/tests/e2e/component-symbols.spec.ts
+8 -8
View File
@@ -107,15 +107,15 @@ function portsForSymbol(modelType: string) {
}
if (modelType === "amesim_pnvo001_fixed") {
return [
physicalPort("port_2", "left", 10),
physicalPort("port_3", "right", 20),
physicalPort("port_2", "right", 10),
physicalPort("port_3", "left", 20),
];
}
if (modelType === "amesim_pnvo001") {
return [
signalPort("res", "left", "input", 5),
physicalPort("port_2", "left", 10),
physicalPort("port_3", "right", 20),
physicalPort("port_2", "right", 10),
physicalPort("port_3", "left", 20),
];
}
if (
@@ -784,8 +784,8 @@ test("PNOR001 与两种 PNVO001 使用统一孔板风格和 small 画布", async
},
{
anchors: [
{ portName: "port_2", x: 12.8, y: 24 },
{ portName: "port_3", x: 51.2, y: 24 },
{ portName: "port_3", x: 12.8, y: 24 },
{ portName: "port_2", x: 51.2, y: 24 },
],
control: "fixed",
modelType: "amesim_pnvo001_fixed",
@@ -794,8 +794,8 @@ test("PNOR001 与两种 PNVO001 使用统一孔板风格和 small 画布", async
{
anchors: [
{ portName: "res", x: 27.35, y: 43.2 },
{ portName: "port_2", x: 12.8, y: 24 },
{ portName: "port_3", x: 51.2, y: 24 },
{ portName: "port_3", x: 12.8, y: 24 },
{ portName: "port_2", x: 51.2, y: 24 },
],
control: "signal",
modelType: "amesim_pnvo001",
frontend/tests/e2e/pnvo-port-display-migration.spec.ts
+54
View File
@@ -0,0 +1,54 @@
import { expect, test } from "@playwright/test";
import { migratedPnvo001Mirrored } from "../../src/pnvoPortDisplayMigration";
const legacyPorts = [
{ name: "res", side: "left" },
{ name: "port_2", side: "left" },
{ name: "port_3", side: "right" },
];
const amesimPorts = [
{ name: "res", side: "left" },
{ name: "port_2", side: "right" },
{ name: "port_3", side: "left" },
];
test("旧 PNVO001 端口快照只迁移一次镜像方向", () => {
for (const modelType of [
"amesim_pnvo001_fixed",
"amesim_pnvo001",
]) {
const migrated = migratedPnvo001Mirrored(
modelType,
legacyPorts,
amesimPorts,
true,
);
expect(migrated).toBe(false);
expect(
migratedPnvo001Mirrored(
modelType,
amesimPorts,
amesimPorts,
migrated,
),
).toBe(false);
expect(
migratedPnvo001Mirrored(
modelType,
legacyPorts,
amesimPorts,
false,
),
).toBe(true);
}
expect(
migratedPnvo001Mirrored(
"amesim_pnor001",
legacyPorts,
amesimPorts,
true,
),
).toBe(true);
});
frontend/tests/e2e/result-event-series.spec.ts
+131
View File
@@ -0,0 +1,131 @@
import { expect, test } from "@playwright/test";
import {
continuousMechanicalForceChartValues,
resultStateTransitionSampleIndices,
segmentedChartPath,
} from "../../src/resultEventSeries";
const mechanicalComponent = {
data: {
ports: [{ name: "port_2", domain: "mechanical" }],
},
};
const mechanicalPortForce = {
scope: "port" as const,
portName: "port_2",
quantity: "force",
category: "flow",
};
test("只分离机械事件中的孤立力尖峰，同时保留连续曲线和原始值", () => {
const time = [0, 0.5, 0.75, 1, 1.5];
const eventIndices = resultStateTransitionSampleIndices(time, {
integration: {
segments: [
{ stateTransitionTimes: [0.75] },
{ stateTransitionTimes: [0.7500000000000001] },
],
},
});
expect([...eventIndices]).toEqual([2]);
const rawForce = [1, 2, 1e12, 3, 4];
const displayedForce = continuousMechanicalForceChartValues(
mechanicalPortForce,
mechanicalComponent,
rawForce,
eventIndices,
);
expect(displayedForce.separatedEventSampleCount).toBe(1);
expect(Number.isNaN(displayedForce.values[2])).toBe(true);
expect(Math.max(...displayedForce.values.filter(Number.isFinite))).toBe(4);
expect(rawForce[2]).toBe(1e12);
const path = segmentedChartPath(
time,
displayedForce.values,
(value) => value,
(value) => value,
);
expect(path.match(/\bM /g)).toHaveLength(1);
const smoothForce = [1, 2, 2.5, 3, 4];
const displayedSmoothForce = continuousMechanicalForceChartValues(
mechanicalPortForce,
mechanicalComponent,
smoothForce,
eventIndices,
);
expect(displayedSmoothForce.values).toBe(smoothForce);
expect(displayedSmoothForce.separatedEventSampleCount).toBe(0);
const componentForce = continuousMechanicalForceChartValues(
{
scope: "component",
portName: null,
quantity: "force",
category: "derived",
},
mechanicalComponent,
[1, 2, -1e12, 3, 4],
eventIndices,
);
expect(componentForce.separatedEventSampleCount).toBe(1);
expect(Number.isNaN(componentForce.values[2])).toBe(true);
const signalForce = continuousMechanicalForceChartValues(
{
scope: "component",
portName: null,
quantity: "force",
category: "signal",
},
mechanicalComponent,
[1, 2, -1e12, 3, 4],
eventIndices,
);
expect(signalForce.values[2]).toBe(-1e12);
expect(signalForce.separatedEventSampleCount).toBe(0);
const stateValues = [0, 0.5, 1e9, 1, 1.5];
const displayedState = continuousMechanicalForceChartValues(
{ ...mechanicalPortForce, quantity: "velocity" },
mechanicalComponent,
stateValues,
eventIndices,
);
expect(displayedState.values).toBe(stateValues);
expect(displayedState.values[2]).toBe(1e9);
const pneumaticForce = continuousMechanicalForceChartValues(
mechanicalPortForce,
{
data: {
ports: [{ name: "port_2", domain: "pneumatic" }],
},
},
rawForce,
eventIndices,
);
expect(pneumaticForce.values).toBe(rawForce);
const persistentContactForce = [0, 0, 1e6, 1e6, 1e6];
const displayedPersistentContactForce =
continuousMechanicalForceChartValues(
mechanicalPortForce,
mechanicalComponent,
persistentContactForce,
eventIndices,
);
expect(displayedPersistentContactForce.values).toBe(
persistentContactForce,
);
expect(
displayedPersistentContactForce.separatedEventSampleCount,
).toBe(0);
expect(
resultStateTransitionSampleIndices(time, {}),
).toEqual(new Set<number>());
});
frontend/tests/e2e/results-chart-windows.spec.ts
+171
View File
@@ -34,6 +34,88 @@ const chartWindowSnapshot = {
},
};
const eventForceSnapshot = {
...chartWindowSnapshot,
id: "e2e-mechanical-event-force-chart",
project: {
...chartWindowSnapshot.project,
nodes: chartWindowSnapshot.project.nodes.map((node, nodeIndex) =>
nodeIndex === 0
? {
...node,
data: {
...node.data,
ports: node.data.ports.map((port, portIndex) =>
portIndex === 0
? { ...port, domain: "mechanical" }
: port,
),
},
}
: node,
),
simulation: {
...chartWindowSnapshot.project.simulation,
t_stop: 2,
step: 0.5,
},
},
result: {
...chartWindowSnapshot.result,
simulatedUntil: 2,
requestedStopTime: 2,
variables: [
...chartWindowSnapshot.result.variables,
{
key: "generic_sensor_1.port_a.f",
componentId: "generic_sensor_1",
componentType: "generic_sensor",
scope: "port",
portName: "port_a",
name: "f",
label: "力",
quantity: "force",
unit: "N",
category: "flow",
order: 30,
},
{
key: "generic_sensor_1.force",
componentId: "generic_sensor_1",
componentType: "generic_sensor",
scope: "component",
portName: null,
name: "force",
label: "接触力",
quantity: "force",
unit: "N",
category: "derived",
order: 31,
},
],
final: {
...chartWindowSnapshot.result.final,
"generic_sensor_1.value": 2,
"generic_sensor_1.port_a.f": 5,
"generic_sensor_1.force": 5,
},
series: {
...chartWindowSnapshot.result.series,
time: [0, 0.5, 0.75, 1, 1.5, 2],
"generic_sensor_1.value": [0, 0.5, 1e9, 1, 1.5, 2],
"generic_sensor_1.port_a.f": [1, 2, 1e12, 3, 4, 5],
"generic_sensor_1.force": [1, 2, -1e12, 3, 4, 5],
},
diagnostics: {
...chartWindowSnapshot.result.diagnostics,
integration: {
segments: [{ stateTransitionTimes: [0.75] }],
},
sampleCount: 6,
},
},
};
async function openResults(page: Page) {
await page.getByRole("tab", { name: "结果", exact: true }).click();
await expect(page.locator(".results-chart-workspace")).toBeVisible();
@@ -129,6 +211,95 @@ test.beforeEach(async ({ page }) => {
}, chartWindowSnapshot);
});
test("机械状态事件力点不参与连续曲线纵轴，但原始数据与非力状态保持不变", async ({
page,
}) => {
await page.addInitScript((snapshot) => {
window.sessionStorage.setItem(
"system-simulation-flow:latest-result",
JSON.stringify(snapshot),
);
}, eventForceSnapshot);
await page.goto("/");
await openResults(page);
await page
.locator(".results-variable-list button")
.filter({ hasText: "port_a · 力" })
.first()
.click();
const forceWindow = page
.locator('.result-chart-window[data-chart-kind="single"]')
.filter({ hasText: "port_a.f" });
await expect(forceWindow).toHaveAttribute(
"data-separated-event-samples",
"1",
);
await expect(forceWindow).toContainText("已隐藏 1 个孤立事件力尖峰");
const forceChart = forceWindow.locator('svg[data-result-chart="true"]');
const forceDomain = await readChartDomain(forceChart);
expect(forceDomain.yMax).toBeLessThan(10);
const forcePath = await forceChart
.locator('path[data-chart-clipped-series="true"]')
.getAttribute("d");
expect(forcePath?.match(/\bM /g)).toHaveLength(1);
const storedEventForce = await page.evaluate(() => {
const raw = sessionStorage.getItem(
"system-simulation-flow:latest-result",
);
return raw
? JSON.parse(raw).result.series["generic_sensor_1.port_a.f"][2]
: null;
});
expect(storedEventForce).toBe(1e12);
await page
.locator(".results-variable-list button")
.filter({ hasText: "接触力" })
.click();
const componentForceWindow = page
.locator('.result-chart-window[data-chart-kind="single"]')
.filter({ hasText: "generic_sensor_1.force" });
await expect(componentForceWindow).toHaveAttribute(
"data-separated-event-samples",
"1",
);
const componentForceDomain = await readChartDomain(
componentForceWindow.locator('svg[data-result-chart="true"]'),
);
expect(componentForceDomain.yMin).toBeGreaterThan(-10);
const storedComponentForce = await page.evaluate(() => {
const raw = sessionStorage.getItem(
"system-simulation-flow:latest-result",
);
return raw
? JSON.parse(raw).result.series["generic_sensor_1.force"][2]
: null;
});
expect(storedComponentForce).toBe(-1e12);
await page
.locator(".results-variable-list button")
.filter({ hasText: "数值" })
.first()
.click();
const stateWindow = page
.locator('.result-chart-window[data-chart-kind="single"]')
.filter({ hasText: "数值" });
await expect(stateWindow).toHaveAttribute(
"data-separated-event-samples",
"0",
);
const stateDomain = await readChartDomain(
stateWindow.locator('svg[data-result-chart="true"]'),
);
expect(stateDomain.yMax).toBeGreaterThan(1e8);
});
test("组合曲线窗口先创建为空窗，并在删除最后一条曲线后恢复待定", async ({
page,
}) => {