fix(stack): match d3 offset none baseline for value order

ljodea · ljodea · commit 7dcc35a6fc85 · 2026-06-22T14:09:16.000-05:00
Narrow STACK_ORDER index type for svelte-check. Use single cumulative
baseline (d3 stackOffsetNone) instead of py/ny split when offset is none.
diff --git a/packages/svelteplot/src/transforms/stack.test.ts b/packages/svelteplot/src/transforms/stack.test.ts
@@ -272,16 +272,16 @@ describe('stackY transform', () => {
                 fill: d[stacked.fill as string]
             }));
 
-        const d3Stack = simplify(stackY<DataRecord>(args, { order: 'sum' }));
         const valueStack = simplify(stackY<DataRecord>(args, { order: 'value' }));
 
-        // same py/ny split as d3 offset none; only sort order within the bucket differs
-        expect(valueStack).toEqual([
-            { y1: -100, y2: 0, fill: 'A' },
-            { y1: -101, y2: -100, fill: 'B' },
-            { y1: 0, y2: 10, fill: 'C' }
-        ]);
-        expect(d3Stack.map((d) => d.fill)).toEqual(valueStack.map((d) => d.fill));
+        const byFill = (rows: typeof valueStack) =>
+            Object.fromEntries(rows.map((d) => [d.fill, d]));
+        // value-sorted bucket with offset none: d3 stackOffsetNone cumulative baseline
+        expect(byFill(valueStack)).toEqual({
+            A: { y1: 0, y2: -100, fill: 'A' },
+            B: { y1: -100, y2: -101, fill: 'B' },
+            C: { y1: -101, y2: -91, fill: 'C' }
+        });
     });
 
     it('order value on unit stacking sorts rows within each x bucket', () => {
diff --git a/packages/svelteplot/src/transforms/stack.ts b/packages/svelteplot/src/transforms/stack.ts
@@ -78,7 +78,8 @@ function stackBucketByValue<T extends DataRecord>(
     byDim: 'x' | 'y',
     byLow: 'x1' | 'y1',
     byHigh: 'x2' | 'y2',
-    reverse: boolean
+    reverse: boolean,
+    offset: 'none' | 'diverging'
 ): T[] {
     const sorted = [...items].sort((a, b) => {
         const av = toStackNumber(a[S[byDim]]);
@@ -94,16 +95,22 @@ function stackBucketByValue<T extends DataRecord>(
         return (a[INDEX] as number) - (b[INDEX] as number);
     });
 
+    const out: T[] = [];
+    let pos = 0;
     let py = 0;
     let ny = 0;
-    const out: T[] = [];
+
     for (const d of sorted) {
         const value = toStackNumber(d[S[byDim]]);
         let low: number;
         let high: number;
         if (value == null || (typeof value === 'number' && Number.isNaN(value))) {
-            low = py;
+            low = offset === 'none' ? pos : py;
             high = NaN;
+        } else if (offset === 'none') {
+            // d3 stackOffsetNone: single cumulative baseline per bucket
+            low = pos;
+            high = pos += value;
         } else if (value >= 0) {
             low = py;
             high = py += value;
@@ -255,13 +262,24 @@ function stackXY<T>(
                     } else {
                         itemsToStack = [...bucketItems];
                     }
+                    const valueOffset = (offset === 'diverging' ? 'diverging' : 'none') as
+                        | 'none'
+                        | 'diverging';
                     out.push(
-                        ...stackBucketByValue(itemsToStack, byDim, byLow, byHigh, options.reverse)
+                        ...stackBucketByValue(
+                            itemsToStack,
+                            byDim,
+                            byLow,
+                            byHigh,
+                            options.reverse,
+                            valueOffset
+                        )
                     );
                 }
             } else {
+                const d3Order = (options.order ?? 'none') as Exclude<StackOrder, 'value'>;
                 const stackOrder = (series: any[]) => {
-                    const f = STACK_ORDER[options.order || 'none'];
+                    const f = STACK_ORDER[d3Order];
                     return options.reverse ? f(series).reverse() : f(series);
                 };
 
