@visactor/vseed 0.4.23 → 0.4.25

package/dist/umd/index.js

@@ -1117,8 +1117,9 @@
                 pivotTableSpecPipeline: ()=>pivotTableSpecPipeline,
                 registerRoseParallel: ()=>registerRoseParallel,
                 terminateWorkerPool: ()=>terminateWorkerPool,
-                zYBandAxis: ()=>zYBandAxis,
+                zDifferenceAnchor: ()=>zDifferenceAnchor,
                 zRaceBar: ()=>zRaceBar,
+                zYBandAxis: ()=>zYBandAxis,
                 zTimeFormat: ()=>zTimeFormat,
                 zRacePie: ()=>zRacePie,
                 DimAxisType: ()=>DimAxisType,
@@ -1192,6 +1193,7 @@
                 zKdeRegressionLine: ()=>zKdeRegressionLine,
                 zDynamicFilter: ()=>zDynamicFilter,
                 zTooltip: ()=>zTooltip,
+                zAnnotationDifferenceLineConfig: ()=>zAnnotationDifferenceLineConfig,
                 zAreaPercentConfig: ()=>zAreaPercentConfig,
                 zPivotChartGridConfig: ()=>zPivotChartGridConfig,
                 zMarkStyle: ()=>zMarkStyle,
@@ -1206,10 +1208,10 @@
                 BinStartMeasureId: ()=>BinStartMeasureId,
                 MeasureEncodingEnum: ()=>MeasureEncodingEnum,
                 ColorEncoding: ()=>ColorEncoding,
-                zLowessRegressionLine: ()=>zLowessRegressionLine,
+                zDifferenceSelectors: ()=>zDifferenceSelectors,
                 heatmapAdvancedPipeline: ()=>heatmapAdvancedPipeline,
                 tableSpecPipeline: ()=>tableSpecPipeline,
-                zTableDynamicFilter: ()=>zTableDynamicFilter,
+                zLowessRegressionLine: ()=>zLowessRegressionLine,
                 zEncoding: ()=>zEncoding,
                 zAreaConfig: ()=>zAreaConfig,
                 registerAll: ()=>registerAll,
@@ -1225,6 +1227,7 @@
                 FoldMeasureValue: ()=>FoldMeasureValue,
                 isVChart: ()=>isVChart,
                 zBrushConfig: ()=>zBrushConfig,
+                zTableDynamicFilter: ()=>zTableDynamicFilter,
                 zTheme: ()=>zTheme,
                 autoFormatter: ()=>autoFormatter,
                 zDatum: ()=>zDatum,
@@ -1235,6 +1238,7 @@
                 zDimensionEncoding: ()=>zDimensionEncoding,
                 zBodyCellStyle: ()=>zBodyCellStyle,
                 barAdvancedPipeline: ()=>barAdvancedPipeline,
+                zDifferenceSelector: ()=>zDifferenceSelector,
                 zTreeMap: ()=>zTreeMap,
                 DUAL_AXIS_CHART_COLUMN_Z_INDEX: ()=>1000,
                 condition: ()=>condition_condition,
@@ -1321,6 +1325,7 @@
                 zLinearColor: ()=>zLinearColor,
                 zCirclePacking: ()=>zCirclePacking,
                 isDualAxisChartType: ()=>isDualAxisChartType,
+                zAnnotationDifferenceLine: ()=>zAnnotationDifferenceLine,
                 raceScatterAdvancedPipeline: ()=>raceScatterAdvancedPipeline,
                 treeMapAdvancedPipeline: ()=>treeMapAdvancedPipeline,
                 barParallelAdvancedPipeline: ()=>barParallelAdvancedPipeline,
@@ -5612,7 +5617,8 @@ self.R = R;
                     'annotationPoint',
                     'annotationHorizontalLine',
                     'annotationVerticalLine',
-                    'annotationArea'
+                    'annotationArea',
+                    'annotationDifferenceLine'
                 ]);
                 return {
                     ...advancedVSeed,
@@ -9147,6 +9153,296 @@ self.R = R;
                 };
                 return result;
             };
+            const toArray = (value)=>{
+                if (Array.isArray(value)) return value;
+                return null == value ? [] : [
+                    value
+                ];
+            };
+            const getDifferenceBandFields = (spec)=>toArray('horizontal' === spec.direction ? spec.yField : spec.xField);
+            const getDifferenceValueField = (spec)=>{
+                const valueField = toArray('horizontal' === spec.direction ? spec.xField : spec.yField)[0];
+                if (!valueField) throw new Error('annotationDifferenceLine requires a value field in the target chart spec');
+                return valueField;
+            };
+            const normalizeDifferenceValue = (value, selectorLabel, field)=>{
+                const numberValue = Number(value);
+                if (Number.isNaN(numberValue)) throw new Error(`annotationDifferenceLine ${selectorLabel} selector resolved to a non-numeric value on field "${field}"`);
+                return numberValue;
+            };
+            const buildStackGroupDatum = (datum, bandFields)=>Object.fromEntries(bandFields.map((field)=>[
+                        field,
+                        datum[field]
+                    ]));
+            const buildFallbackSelectorDatum = (selectorValue)=>{
+                const selectorList = Array.isArray(selectorValue) ? selectorValue : [
+                    selectorValue
+                ];
+                const fallbackDatum = {};
+                for (const currentSelector of selectorList){
+                    if (isValueSelector(currentSelector) || isFieldSelector(currentSelector)) return;
+                    if (isMeasureSelector(currentSelector)) {
+                        const operator = currentSelector.operator || currentSelector.op;
+                        const selectorValues = Array.isArray(currentSelector.value) ? currentSelector.value : [
+                            currentSelector.value
+                        ];
+                        if (![
+                            '=',
+                            '=='
+                        ].includes(operator) || 1 !== selectorValues.length) return;
+                        fallbackDatum[currentSelector.field] = selectorValues[0];
+                        continue;
+                    }
+                    if (isDimensionSelector(currentSelector)) {
+                        const operator = currentSelector.operator || currentSelector.op;
+                        const selectorValues = Array.isArray(currentSelector.value) ? currentSelector.value : [
+                            currentSelector.value
+                        ];
+                        if ('in' !== operator || 1 !== selectorValues.length) return;
+                        fallbackDatum[currentSelector.field] = selectorValues[0];
+                        continue;
+                    }
+                    if (isPartialDatumSelector(currentSelector)) {
+                        Object.assign(fallbackDatum, currentSelector);
+                        continue;
+                    }
+                    return;
+                }
+                return Object.keys(fallbackDatum).length > 0 ? fallbackDatum : void 0;
+            };
+            const inferFallbackValue = (fallbackDatum, valueField, bandFields)=>{
+                if (valueField in fallbackDatum) return fallbackDatum[valueField];
+                const numericCandidateKeys = Object.keys(fallbackDatum).filter((key)=>{
+                    if (key === valueField || bandFields.includes(key)) return false;
+                    return 'number' == typeof fallbackDatum[key];
+                });
+                if (1 !== numericCandidateKeys.length) return;
+                return fallbackDatum[numericCandidateKeys[0]];
+            };
+            const resolveFallbackAnchor = (options)=>{
+                const { selectorLabel, selectorValue, valueField, bandFields } = options;
+                const fallbackDatum = buildFallbackSelectorDatum(selectorValue);
+                if (!fallbackDatum) return;
+                const inferredValue = inferFallbackValue(fallbackDatum, valueField, bandFields);
+                if (void 0 === inferredValue) return;
+                const coordinateDatum = {
+                    ...fallbackDatum,
+                    [valueField]: inferredValue
+                };
+                try {
+                    return {
+                        selectorLabel,
+                        coordinateDatum,
+                        matchedDatum: fallbackDatum,
+                        value: normalizeDifferenceValue(inferredValue, selectorLabel, valueField)
+                    };
+                } catch  {
+                    return;
+                }
+            };
+            const hasMixedSigns = (values)=>{
+                const nonZeroValues = values.filter((value)=>0 !== value);
+                return nonZeroValues.some((value)=>value > 0) && nonZeroValues.some((value)=>value < 0);
+            };
+            const isDifferenceLineStacked = (vseed, advancedVSeed)=>('column' === vseed.chartType || 'bar' === vseed.chartType) && hasMultipleMeasureInSingleView(advancedVSeed.reshapeMeasures ?? []);
+            const resolveDifferenceAnchor = (options)=>{
+                const { dataset, selectorLabel, selectorValue, spec, isStacked } = options;
+                const matches = dataset.filter((datum)=>selector_selector(datum, selectorValue));
+                const valueField = getDifferenceValueField(spec);
+                const bandFields = getDifferenceBandFields(spec);
+                if (0 === matches.length) return isStacked ? void 0 : resolveFallbackAnchor({
+                    selectorLabel,
+                    selectorValue,
+                    valueField,
+                    bandFields
+                });
+                if (!isStacked) {
+                    if (1 !== matches.length) throw new Error(`annotationDifferenceLine ${selectorLabel} selector must resolve to exactly one datum, got ${matches.length}`);
+                    return {
+                        selectorLabel,
+                        coordinateDatum: matches[0],
+                        matchedDatum: matches[0],
+                        value: normalizeDifferenceValue(matches[0][valueField], selectorLabel, valueField)
+                    };
+                }
+                const stackGroups = new Map();
+                matches.forEach((datum)=>{
+                    const stackGroupDatum = buildStackGroupDatum(datum, bandFields);
+                    stackGroups.set(JSON.stringify(stackGroupDatum), stackGroupDatum);
+                });
+                if (1 !== stackGroups.size) throw new Error(`annotationDifferenceLine ${selectorLabel} selector must resolve to exactly one stack group, got ${stackGroups.size}`);
+                const stackGroupDatum = Array.from(stackGroups.values())[0];
+                const groupRows = dataset.filter((datum)=>isSubset(stackGroupDatum, datum));
+                const groupValues = groupRows.map((datum)=>normalizeDifferenceValue(datum[valueField], selectorLabel, valueField));
+                if (hasMixedSigns(groupValues)) throw new Error('annotationDifferenceLine does not support mixed-sign stack totals in v1');
+                return {
+                    selectorLabel,
+                    coordinateDatum: stackGroupDatum,
+                    matchedDatum: matches[0],
+                    stackGroupDatum,
+                    value: groupValues.reduce((sum, value)=>sum + value, 0)
+                };
+            };
+            const getStackRuntimeTotal = (runtimeMatches)=>{
+                const stackEndValues = runtimeMatches.map((datum)=>Number(datum.__VCHART_STACK_END));
+                if (stackEndValues.some((value)=>Number.isNaN(value))) return;
+                if (hasMixedSigns(stackEndValues)) throw new Error('annotationDifferenceLine does not support mixed-sign runtime stack totals in v1');
+                return stackEndValues.some((value)=>value < 0) ? Math.min(...stackEndValues) : Math.max(...stackEndValues);
+            };
+            const buildDifferenceCoordinateDatum = (options)=>{
+                const { anchor, seriesData, relativeSeries } = options;
+                if (!anchor.stackGroupDatum) {
+                    const runtimeMatches = anchor.matchedDatum ? seriesData.filter((datum)=>isSubset(anchor.matchedDatum, datum)) : [];
+                    return runtimeMatches[0] ?? anchor.coordinateDatum;
+                }
+                const runtimeMatches = seriesData.filter((datum)=>isSubset(anchor.stackGroupDatum, datum));
+                const runtimeStackTotal = getStackRuntimeTotal(runtimeMatches);
+                return {
+                    ...runtimeMatches[0] ?? anchor.coordinateDatum,
+                    [relativeSeries.getStackValueField()]: runtimeStackTotal ?? anchor.value
+                };
+            };
+            const buildDifferenceText = (startValue, endValue, differenceType = 'absolute')=>{
+                if ('percent' === differenceType) {
+                    if (0 === startValue) throw new Error('annotationDifferenceLine percent difference cannot be computed because start value is 0');
+                    return `${((endValue - startValue) / startValue * 100).toFixed(0)}%`;
+                }
+                return `${endValue - startValue}`;
+            };
+            const inferDifferenceConnectDirection = (vseed, values)=>{
+                const isNegativeSide = values.every((value)=>value < 0);
+                if (isBarLikeChart(vseed)) return isNegativeSide ? 'left' : 'right';
+                return isNegativeSide ? 'bottom' : 'top';
+            };
+            const DEFAULT_LINE_COLOR = '#BCC1CB';
+            const DEFAULT_TEXT_COLOR = '#ffffff';
+            const DEFAULT_TEXT_BACKGROUND_COLOR = '#BCC1CB';
+            const DEFAULT_TEXT_FONT_SIZE = 12;
+            const DEFAULT_EXPAND_DISTANCE = 24;
+            const DEFAULT_LINE_WIDTH = 2;
+            const DEFAULT_CORNER_RADIUS = 4;
+            const DEFAULT_LABEL_PADDING = 4;
+            const DEFAULT_END_SYMBOL_SIZE = 12;
+            const DEFAULT_END_SYMBOL_REF_X = -4;
+            const getDifferenceLinePath = (index, total)=>1 === total ? 'annotationDifferenceLine' : `annotationDifferenceLine[${index}]`;
+            const assertDifferenceLineConfig = (value, path)=>{
+                if ('object' != typeof value || null === value || Array.isArray(value)) throw new Error(`${path} must be an object`);
+                const start = value.start;
+                if ('object' != typeof start || null === start || Array.isArray(start)) throw new Error(`${path}.start is required`);
+                if (null == start.selector) throw new Error(`${path}.start.selector is required`);
+                const end = value.end;
+                if ('object' != typeof end || null === end || Array.isArray(end)) throw new Error(`${path}.end is required`);
+                if (null == end.selector) throw new Error(`${path}.end.selector is required`);
+            };
+            const annotationDifferenceLine_annotationDifferenceLine = (spec, context)=>{
+                const { advancedVSeed, vseed } = context;
+                const annotationDifferenceLine = advancedVSeed.annotation?.annotationDifferenceLine;
+                if (!annotationDifferenceLine) return spec;
+                const theme = advancedVSeed.config?.[vseed.chartType]?.annotation?.annotationDifferenceLine;
+                const annotationDifferenceLineList = Array.isArray(annotationDifferenceLine) ? annotationDifferenceLine : [
+                    annotationDifferenceLine
+                ];
+                const dataset = advancedVSeed.dataset.flat();
+                const barSpec = spec;
+                const isStacked = isDifferenceLineStacked(vseed, advancedVSeed);
+                const markLine = annotationDifferenceLineList.flatMap((annotationDifferenceLine, index)=>{
+                    assertDifferenceLineConfig(annotationDifferenceLine, getDifferenceLinePath(index, annotationDifferenceLineList.length));
+                    const start = resolveDifferenceAnchor({
+                        dataset,
+                        selectorLabel: 'start',
+                        selectorValue: annotationDifferenceLine.start.selector,
+                        spec: barSpec,
+                        isStacked
+                    });
+                    const end = resolveDifferenceAnchor({
+                        dataset,
+                        selectorLabel: 'end',
+                        selectorValue: annotationDifferenceLine.end.selector,
+                        spec: barSpec,
+                        isStacked
+                    });
+                    if (!start || !end) return [];
+                    const lineColor = annotationDifferenceLine.lineColor ?? theme?.lineColor ?? DEFAULT_LINE_COLOR;
+                    const textColor = annotationDifferenceLine.textColor ?? theme?.textColor ?? DEFAULT_TEXT_COLOR;
+                    const textBackgroundColor = annotationDifferenceLine.textBackgroundColor ?? theme?.textBackgroundColor ?? DEFAULT_TEXT_BACKGROUND_COLOR;
+                    const textFontSize = annotationDifferenceLine.textFontSize ?? theme?.textFontSize ?? DEFAULT_TEXT_FONT_SIZE;
+                    return [
+                        {
+                            type: 'type-step',
+                            autoRange: true,
+                            zIndex: 1000,
+                            connectDirection: inferDifferenceConnectDirection(vseed, [
+                                start.value,
+                                end.value
+                            ]),
+                            expandDistance: DEFAULT_EXPAND_DISTANCE,
+                            coordinates: (seriesData, relativeSeries)=>[
+                                    buildDifferenceCoordinateDatum({
+                                        anchor: start,
+                                        seriesData,
+                                        relativeSeries
+                                    }),
+                                    buildDifferenceCoordinateDatum({
+                                        anchor: end,
+                                        seriesData,
+                                        relativeSeries
+                                    })
+                                ],
+                            line: {
+                                style: {
+                                    visible: true,
+                                    stroke: lineColor,
+                                    lineWidth: DEFAULT_LINE_WIDTH,
+                                    lineDash: [
+                                        0
+                                    ],
+                                    cornerRadius: DEFAULT_CORNER_RADIUS
+                                }
+                            },
+                            label: {
+                                confine: true,
+                                visible: true,
+                                position: 'middle',
+                                text: buildDifferenceText(start.value, end.value, annotationDifferenceLine.differenceType ?? 'absolute'),
+                                style: {
+                                    fill: textColor,
+                                    fontSize: textFontSize
+                                },
+                                labelBackground: {
+                                    visible: true,
+                                    padding: DEFAULT_LABEL_PADDING,
+                                    style: {
+                                        fill: textBackgroundColor,
+                                        fillOpacity: 1,
+                                        stroke: lineColor,
+                                        lineWidth: 1,
+                                        cornerRadius: DEFAULT_CORNER_RADIUS
+                                    }
+                                }
+                            },
+                            startSymbol: {
+                                visible: false
+                            },
+                            endSymbol: {
+                                visible: true,
+                                size: DEFAULT_END_SYMBOL_SIZE,
+                                refX: DEFAULT_END_SYMBOL_REF_X,
+                                style: {
+                                    fill: lineColor
+                                }
+                            }
+                        }
+                    ];
+                });
+                const specMarkLine = barSpec.markLine || [];
+                return {
+                    ...spec,
+                    markLine: [
+                        ...specMarkLine,
+                        ...markLine
+                    ]
+                };
+            };
             const annotationAreaBand = (spec, context)=>{
                 const { advancedVSeed, vseed } = context;
                 const { annotation, config } = advancedVSeed;
@@ -9762,6 +10058,7 @@ self.R = R;
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
+                annotationDifferenceLine_annotationDifferenceLine,
                 annotationAreaBand,
                 columnPolynomialRegressionLine
             ];
@@ -9792,6 +10089,7 @@ self.R = R;
                     annotationPoint_annotationPoint,
                     annotationVerticalLine_annotationVerticalLine,
                     annotationHorizontalLine_annotationHorizontalLine,
+                    annotationDifferenceLine_annotationDifferenceLine,
                     annotationAreaBand,
                     columnPolynomialRegressionLine
                 ]),
@@ -9977,6 +10275,7 @@ self.R = R;
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
+                annotationDifferenceLine_annotationDifferenceLine,
                 annotationAreaBand
             ];
             const pivotColumnParallel = [
@@ -10005,6 +10304,7 @@ self.R = R;
                     annotationPoint_annotationPoint,
                     annotationVerticalLine_annotationVerticalLine,
                     annotationHorizontalLine_annotationHorizontalLine,
+                    annotationDifferenceLine_annotationDifferenceLine,
                     annotationAreaBand
                 ]),
                 pivotRowDimensions,
@@ -10461,6 +10761,7 @@ self.R = R;
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
+                annotationDifferenceLine_annotationDifferenceLine,
                 annotationAreaBand
             ];
             const pivotBar = [
@@ -10489,6 +10790,7 @@ self.R = R;
                     annotationPoint_annotationPoint,
                     annotationVerticalLine_annotationVerticalLine,
                     annotationHorizontalLine_annotationHorizontalLine,
+                    annotationDifferenceLine_annotationDifferenceLine,
                     annotationAreaBand
                 ]),
                 pivotRowDimensions,
@@ -13211,6 +13513,7 @@ self.R = R;
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
+                annotationDifferenceLine_annotationDifferenceLine,
                 annotationAreaBand
             ];
             const pivotBarParallel = [
@@ -13238,6 +13541,7 @@ self.R = R;
                     annotationPoint_annotationPoint,
                     annotationVerticalLine_annotationVerticalLine,
                     annotationHorizontalLine_annotationHorizontalLine,
+                    annotationDifferenceLine_annotationDifferenceLine,
                     annotationAreaBand
                 ]),
                 pivotRowDimensions,
@@ -19389,6 +19693,15 @@ self.R = R;
                     textBackgroundBorderColor: '#BCC1CB'
                 });
             const getLightAnnotationVerticalLine = ()=>getLightAnnotationHorizontalLine();
+            const getDefaultAnnotationDifferenceLine = ()=>({
+                    textFontSize: 12
+                });
+            const getLightAnnotationDifferenceLine = ()=>({
+                    ...getDefaultAnnotationDifferenceLine(),
+                    lineColor: '#BCC1CB',
+                    textColor: '#ffffff',
+                    textBackgroundColor: '#BCC1CB'
+                });
             const getDefaultAnnotationArea = ()=>({
                     textFontSize: 12,
                     textFontWeight: 400,
@@ -19417,6 +19730,7 @@ self.R = R;
                     annotationPoint: getLightAnnotationPoint(),
                     annotationHorizontalLine: getLightAnnotationHorizontalLine(),
                     annotationVerticalLine: getLightAnnotationVerticalLine(),
+                    annotationDifferenceLine: getLightAnnotationDifferenceLine(),
                     annotationArea: getLightAnnotationArea()
                 });
             const getDarkAnnotationPoint = ()=>({
@@ -19433,6 +19747,12 @@ self.R = R;
                     textBackgroundBorderColor: '#55595F'
                 });
             const getDarkAnnotationVerticalLine = ()=>getDarkAnnotationHorizontalLine();
+            const getDarkAnnotationDifferenceLine = ()=>({
+                    ...getDefaultAnnotationDifferenceLine(),
+                    lineColor: '#55595F',
+                    textColor: '#E2E3E6',
+                    textBackgroundColor: '#55595F'
+                });
             const getDarkAnnotationArea = ()=>({
                     ...getDefaultAnnotationArea(),
                     textColor: '#E2E3E6',
@@ -19446,6 +19766,7 @@ self.R = R;
                     annotationPoint: getDarkAnnotationPoint(),
                     annotationHorizontalLine: getDarkAnnotationHorizontalLine(),
                     annotationVerticalLine: getDarkAnnotationVerticalLine(),
+                    annotationDifferenceLine: getDarkAnnotationDifferenceLine(),
                     annotationArea: getDarkAnnotationArea()
                 });
             const getLightLinearAxis = ()=>({
@@ -25094,6 +25415,30 @@ self.R = R;
                 offsetY: schemas_number().default(0).nullish(),
                 offsetX: schemas_number().default(0).nullish()
             });
+            const zDifferenceSelector = union([
+                zPartialSelector,
+                zMeasureSelector,
+                zDimensionSelector
+            ]);
+            const zDifferenceSelectors = schemas_array(zDifferenceSelector);
+            const zDifferenceAnchor = schemas_object({
+                selector: union([
+                    zDifferenceSelector,
+                    zDifferenceSelectors
+                ])
+            });
+            const zAnnotationDifferenceLine = schemas_object({
+                start: zDifferenceAnchor,
+                end: zDifferenceAnchor,
+                differenceType: schemas_enum([
+                    'absolute',
+                    'percent'
+                ]).nullish(),
+                textFontSize: schemas_number().nullish(),
+                textColor: schemas_string().nullish(),
+                textBackgroundColor: schemas_string().nullish(),
+                lineColor: schemas_string().nullish()
+            });
             const zAnnotationHorizontalLine = schemas_object({
                 yValue: union([
                     schemas_number(),
@@ -25229,11 +25574,18 @@ self.R = R;
                 areaLineDash: true,
                 outerPadding: true
             }).partial();
+            const zAnnotationDifferenceLineConfig = zAnnotationDifferenceLine.pick({
+                lineColor: true,
+                textColor: true,
+                textFontSize: true,
+                textBackgroundColor: true
+            }).partial();
             const zAnnotationConfig = schemas_object({
                 annotationPoint: zAnnotationPointConfig.nullish(),
                 annotationHorizontalLine: zAnnotationHorizontalLineConfig.nullish(),
                 annotationVerticalLine: zAnnotationVerticalLineConfig.nullish(),
-                annotationArea: zAnnotationAreaConfig.nullish()
+                annotationArea: zAnnotationAreaConfig.nullish(),
+                annotationDifferenceLine: zAnnotationDifferenceLineConfig.nullish()
             });
             const zPivotChartGridConfig = schemas_object({
                 borderColor: schemas_string().nullish(),
@@ -25789,7 +26141,8 @@ self.R = R;
                 annotationPoint: zAnnotationPoint.or(schemas_array(zAnnotationPoint)).nullish(),
                 annotationVerticalLine: zAnnotationVerticalLine.or(schemas_array(zAnnotationVerticalLine)).nullish(),
                 annotationHorizontalLine: zAnnotationHorizontalLine.or(schemas_array(zAnnotationHorizontalLine)).nullish(),
-                annotationArea: zAnnotationArea.or(schemas_array(zAnnotationArea)).nullish()
+                annotationArea: zAnnotationArea.or(schemas_array(zAnnotationArea)).nullish(),
+                annotationDifferenceLine: zAnnotationDifferenceLine.or(schemas_array(zAnnotationDifferenceLine)).nullish()
             });
             const zSort = schemas_object({
                 order: schemas_enum([
@@ -25964,6 +26317,7 @@ self.R = R;
                 annotationVerticalLine: schemas_array(zAnnotationVerticalLine).or(zAnnotationVerticalLine).nullish(),
                 annotationHorizontalLine: schemas_array(zAnnotationHorizontalLine).or(zAnnotationHorizontalLine).nullish(),
                 annotationArea: schemas_array(zAnnotationArea).or(zAnnotationArea).nullish(),
+                annotationDifferenceLine: schemas_array(zAnnotationDifferenceLine).or(zAnnotationDifferenceLine).nullish(),
                 polynomialRegressionLine: schemas_array(zPolynomialRegressionLine).or(zPolynomialRegressionLine).nullish(),
                 dimensionLinkage: zDimensionLinkage.nullish(),
                 locale: zLocale.nullish()
@@ -25994,6 +26348,7 @@ self.R = R;
                 annotationVerticalLine: schemas_array(zAnnotationVerticalLine).or(zAnnotationVerticalLine).nullish(),
                 annotationHorizontalLine: schemas_array(zAnnotationHorizontalLine).or(zAnnotationHorizontalLine).nullish(),
                 annotationArea: schemas_array(zAnnotationArea).or(zAnnotationArea).nullish(),
+                annotationDifferenceLine: schemas_array(zAnnotationDifferenceLine).or(zAnnotationDifferenceLine).nullish(),
                 dimensionLinkage: zDimensionLinkage.nullish(),
                 locale: zLocale.nullish()
             });
@@ -26048,6 +26403,7 @@ self.R = R;
                 annotationVerticalLine: schemas_array(zAnnotationVerticalLine).or(zAnnotationVerticalLine).nullish(),
                 annotationHorizontalLine: schemas_array(zAnnotationHorizontalLine).or(zAnnotationHorizontalLine).nullish(),
                 annotationArea: schemas_array(zAnnotationArea).or(zAnnotationArea).nullish(),
+                annotationDifferenceLine: schemas_array(zAnnotationDifferenceLine).or(zAnnotationDifferenceLine).nullish(),
                 dimensionLinkage: zDimensionLinkage.nullish(),
                 locale: zLocale.nullish()
             });
@@ -26193,6 +26549,7 @@ self.R = R;
                 annotationVerticalLine: schemas_array(zAnnotationVerticalLine).or(zAnnotationVerticalLine).nullish(),
                 annotationHorizontalLine: schemas_array(zAnnotationHorizontalLine).or(zAnnotationHorizontalLine).nullish(),
                 annotationArea: schemas_array(zAnnotationArea).or(zAnnotationArea).nullish(),
+                annotationDifferenceLine: schemas_array(zAnnotationDifferenceLine).or(zAnnotationDifferenceLine).nullish(),
                 dimensionLinkage: zDimensionLinkage.nullish(),
                 locale: zLocale.nullish(),
                 page: zPage.nullish()
@@ -26803,6 +27160,9 @@ self.R = R;
                     annotationVerticalLine: {
                         textFontSize: tokens.labelFontSize
                     },
+                    annotationDifferenceLine: {
+                        textFontSize: tokens.labelFontSize
+                    },
                     annotationArea: {
                         textFontSize: tokens.labelFontSize
                     }