svelteplot 0.3.11-pr-153.10 → 0.3.11-pr-153.12

package/dist/transforms/index.d.ts

@@ -12,5 +12,5 @@ export { renameChannels, replaceChannels } from './rename.js';
 export { select, selectFirst, selectLast, selectMaxX, selectMaxY, selectMinX, selectMinY } from './select.js';
 export { shiftX, shiftY } from './shift.js';
 export { sort, shuffle, reverse } from './sort.js';
-export { stackX, stackY, stackMosaic } from './stack.js';
+export { stackX, stackY, stackMosaicX, stackMosaicY } from './stack.js';
 export { windowX, windowY } from './window.js';

package/dist/transforms/index.js

@@ -12,5 +12,5 @@ export { renameChannels, replaceChannels } from './rename.js';
 export { select, selectFirst, selectLast, selectMaxX, selectMaxY, selectMinX, selectMinY } from './select.js';
 export { shiftX, shiftY } from './shift.js';
 export { sort, shuffle, reverse } from './sort.js';
-export { stackX, stackY, stackMosaic } from './stack.js';
+export { stackX, stackY, stackMosaicX, stackMosaicY } from './stack.js';
 export { windowX, windowY } from './window.js';

package/dist/transforms/stack.d.ts

@@ -1,4 +1,4 @@
-import type { ChannelAccessor, TransformArg } from '../types/index.js';
+import type { TransformArg } from '../types/index.js';
 export type StackOrder = 'none' | 'appearance' | 'inside-out' | 'sum';
 export type StackOffset = 'none' | 'wiggle' | 'center' | 'normalize' | 'diverging';
 export type StackOptions = {
@@ -8,18 +8,21 @@ export type StackOptions = {
 };
 export declare function stackY<T>({ data, ...channels }: T, opts?: Partial<StackOptions>): T;
 export declare function stackX({ data, ...channels }: TransformArg, opts?: Partial<StackOptions>): TransformArg;
-export declare function stackMosaic<T>(args: {
-    data: T[];
-    x: ChannelAccessor<T>;
-    y: ChannelAccessor<T>;
-    value: ChannelAccessor<T>;
-    fx?: ChannelAccessor<T>;
-    fy?: ChannelAccessor<T>;
-}, { x: xOpt, y: yOpt }?: {
-    x?: {
-        percent?: boolean;
-    };
-    y?: {
-        percent?: boolean;
-    };
-}): any;
+export declare function stackMosaicX<T>(args: any, opts: any): {
+    data: unknown[];
+    x: symbol;
+    x1: symbol;
+    x2: symbol;
+    y: symbol;
+    y1: symbol;
+    y2: symbol;
+};
+export declare function stackMosaicY<T>(args: any, opts: any): {
+    data: unknown[];
+    x: symbol;
+    x1: symbol;
+    x2: symbol;
+    y: symbol;
+    y1: symbol;
+    y2: symbol;
+};

package/dist/transforms/stack.js

@@ -119,49 +119,63 @@ const X2 = Symbol('x2');
 const Y = Symbol('y');
 const Y1 = Symbol('y1');
 const Y2 = Symbol('y2');
-export function stackMosaic(args, { x: xOpt, y: yOpt } = {}) {
+function stackMosaic({ data, x, y, value, fx, fy, ...rest }, { outer, inner }, { x: xOpt, y: yOpt } = {}) {
     const out = [];
-    const { data, x, y, value, ...rest } = sort(filter(args));
-    if (data == null)
+    const { data: filtered, ...restArgs } = sort(filter({ data, x, y, value, fx, fy, ...rest }));
+    if (!filtered)
         throw new Error('stackMosaic: missing data');
-    if (x == null)
+    if (!x)
         throw new Error('stackMosaic: missing x channel');
-    if (y == null)
+    if (!y)
         throw new Error('stackMosaic: missing y channel');
-    if (value == null)
+    if (!value)
         throw new Error('stackMosaic: missing value channel');
-    if (min(data, (d) => resolveProp(d[value], d)) < 0)
+    if (min(filtered, (d) => resolveProp(d[value], d)) < 0)
         throw new Error('stackMosaic: negative values not supported');
-    groupFacetsAndZ(data, { ...rest }, (data) => {
-        const total = sum(data, (d) => d[value]);
-        let xPos = 0;
-        const grouped = d3Groups(data, (d) => resolveProp(d[x], d));
-        const yOrder = new Map(grouped[0][1].map((d, i) => [d[y], i]));
-        const flat = grouped.flatMap(([k, items], i) => {
+    groupFacetsAndZ(filtered, restArgs, (data) => {
+        const total = sum(data, (d) => resolveProp(d[value], d));
+        let outerPos = 0;
+        const outerChannel = outer === 'x' ? x : y;
+        const innerChannel = inner === 'x' ? x : y;
+        const outerSym1 = outer === 'x' ? X1 : Y1;
+        const outerSym2 = outer === 'x' ? X2 : Y2;
+        const innerSym1 = inner === 'x' ? X1 : Y1;
+        const innerSym2 = inner === 'x' ? X2 : Y2;
+        const outerOpt = outer === 'x' ? xOpt : yOpt;
+        const innerOpt = inner === 'x' ? xOpt : yOpt;
+        const grouped = d3Groups(data, (d) => resolveProp(d[outerChannel], d));
+        const innerOrder = new Map(grouped[0][1].map((d, i) => [d[innerChannel], i]));
+        grouped.forEach(([k, items], i) => {
             const groupValue = sum(items, (d) => resolveProp(d[value], d));
-            const x1 = xPos;
-            const x2 = xPos + groupValue;
-            xPos = x2;
-            let yPos = 0;
-            return (!i ? items : items.sort((a, b) => yOrder.get(a[y]) - yOrder.get(b[y]))).map((d) => {
-                const y1 = yPos, y2 = yPos + resolveProp(d[value], d);
-                yPos = y2;
-                const normX1 = xOpt?.percent ? x1 / total : x1;
-                const normX2 = xOpt?.percent ? x2 / total : x2;
-                const normY1 = yOpt?.percent ? y1 / groupValue : y1;
-                const normY2 = yOpt?.percent ? y2 / groupValue : y2;
-                return {
-                    ...d,
-                    [X1]: normX1,
-                    [X2]: normX2,
-                    [Y1]: normY1,
-                    [Y2]: normY2,
-                    [X]: (normX1 + normX2) / 2,
-                    [Y]: (normY1 + normY2) / 2
-                };
+            const o1 = outerPos, o2 = outerPos + groupValue;
+            outerPos = o2;
+            let innerPos = 0;
+            (i
+                ? items.sort((a, b) => innerOrder.get(a[innerChannel]) - innerOrder.get(b[innerChannel]))
+                : items).forEach((d) => {
+                const iv = resolveProp(d[value], d);
+                const i1 = innerPos, i2 = innerPos + iv;
+                innerPos = i2;
+                const normO1 = outerOpt?.percent ? o1 / total : o1;
+                const normO2 = outerOpt?.percent ? o2 / total : o2;
+                const normI1 = innerOpt?.percent ? i1 / groupValue : i1;
+                const normI2 = innerOpt?.percent ? i2 / groupValue : i2;
+                const result = { ...d };
+                result[outerSym1] = normO1;
+                result[outerSym2] = normO2;
+                result[innerSym1] = normI1;
+                result[innerSym2] = normI2;
+                result[X] = (result[X1] + result[X2]) / 2;
+                result[Y] = (result[Y1] + result[Y2]) / 2;
+                out.push(result);
             });
         });
-        out.push(...flat);
     });
     return { ...rest, data: out, x: X, x1: X1, x2: X2, y: Y, y1: Y1, y2: Y2 };
 }
+export function stackMosaicX(args, opts) {
+    return stackMosaic(args, { outer: 'x', inner: 'y' }, opts);
+}
+export function stackMosaicY(args, opts) {
+    return stackMosaic(args, { outer: 'y', inner: 'x' }, opts);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "svelteplot",
-    "version": "0.3.11-pr-153.10",
+    "version": "0.3.11-pr-153.12",
     "license": "ISC",
     "author": {
         "name": "Gregor Aisch",