@pallasoft/ps-mobile-components 1.3.0 → 1.4.0

package/dist/services/ps-material-control-service.d.ts

@@ -0,0 +1,9 @@
+import type { PsMaterialScheme } from '../interfaces/ps-material-scheme';
+import type { PsMaterialSegmentedColors } from '../interfaces/ps-material-segmented-colors';
+import type { PsMaterialSwitchColors } from '../interfaces/ps-material-switch-colors';
+export declare class PsMaterialControlService {
+    static switchColors(scheme: PsMaterialScheme): PsMaterialSwitchColors;
+    static segmentedColors(scheme: PsMaterialScheme): PsMaterialSegmentedColors;
+    private static disabledContent;
+    private static disabledContainer;
+}

package/dist/services/ps-material-control-service.js

@@ -0,0 +1,46 @@
+import { PsAndroidStateConfig } from '../constants/ps-android-state-config';
+import { PsMobileColorService } from './ps-mobile-color-service';
+export class PsMaterialControlService {
+    static switchColors(scheme) {
+        const disabledContent = PsMaterialControlService.disabledContent(scheme);
+        const disabledContainer = PsMaterialControlService.disabledContainer(scheme);
+        return {
+            checkedBorderColor: scheme.primary,
+            checkedThumbColor: scheme.onPrimary,
+            checkedTrackColor: scheme.primary,
+            disabledCheckedBorderColor: disabledContainer,
+            disabledCheckedThumbColor: scheme.surface,
+            disabledCheckedTrackColor: disabledContainer,
+            disabledUncheckedBorderColor: disabledContainer,
+            disabledUncheckedThumbColor: disabledContent,
+            disabledUncheckedTrackColor: scheme.surface,
+            uncheckedBorderColor: scheme.outline,
+            uncheckedThumbColor: scheme.outline,
+            uncheckedTrackColor: scheme.surfaceContainerHighest,
+        };
+    }
+    static segmentedColors(scheme) {
+        const disabledContent = PsMaterialControlService.disabledContent(scheme);
+        const disabledContainer = PsMaterialControlService.disabledContainer(scheme);
+        return {
+            activeBorderColor: scheme.primary,
+            activeContainerColor: scheme.primaryContainer,
+            activeContentColor: scheme.onPrimaryContainer,
+            disabledActiveBorderColor: disabledContainer,
+            disabledActiveContainerColor: disabledContainer,
+            disabledActiveContentColor: disabledContent,
+            disabledInactiveBorderColor: disabledContainer,
+            disabledInactiveContainerColor: scheme.surface,
+            disabledInactiveContentColor: disabledContent,
+            inactiveBorderColor: scheme.outlineVariant,
+            inactiveContainerColor: scheme.surface,
+            inactiveContentColor: scheme.onSurfaceVariant,
+        };
+    }
+    static disabledContent(scheme) {
+        return PsMobileColorService.withAlpha(scheme.onSurface, PsAndroidStateConfig.disabledContentAlpha);
+    }
+    static disabledContainer(scheme) {
+        return PsMobileColorService.withAlpha(scheme.onSurface, PsAndroidStateConfig.disabledContainerAlpha);
+    }
+}

package/dist/services/ps-material-scheme-service.d.ts

@@ -0,0 +1,5 @@
+import type { PsMaterialScheme } from '../interfaces/ps-material-scheme';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsMaterialSchemeService {
+    static create(theme: PsMobileTheme): PsMaterialScheme;
+}

package/dist/services/ps-material-scheme-service.js

@@ -0,0 +1,42 @@
+export class PsMaterialSchemeService {
+    static create(theme) {
+        return {
+            background: theme.background,
+            error: theme.danger,
+            errorContainer: theme.dangerSoft,
+            inverseOnSurface: theme.surface,
+            inversePrimary: theme.primary,
+            inverseSurface: theme.ink,
+            onBackground: theme.ink,
+            onError: theme.white,
+            onErrorContainer: theme.dangerText,
+            onPrimary: theme.primaryContrast,
+            onPrimaryContainer: theme.primaryText,
+            onSecondary: theme.secondaryContrast,
+            onSecondaryContainer: theme.secondaryText,
+            onSurface: theme.ink,
+            onSurfaceVariant: theme.muted,
+            onTertiary: theme.white,
+            onTertiaryContainer: theme.infoText,
+            outline: theme.muted,
+            outlineVariant: theme.line,
+            primary: theme.primary,
+            primaryContainer: theme.primarySoftStrong,
+            scrim: theme.overlay,
+            secondary: theme.secondary,
+            secondaryContainer: theme.secondarySoft,
+            surface: theme.surface,
+            surfaceBright: theme.surface,
+            surfaceContainer: theme.surface,
+            surfaceContainerHigh: theme.background,
+            surfaceContainerHighest: theme.background,
+            surfaceContainerLow: theme.surface,
+            surfaceContainerLowest: theme.surface,
+            surfaceDim: theme.background,
+            surfaceTint: theme.primary,
+            surfaceVariant: theme.background,
+            tertiary: theme.info,
+            tertiaryContainer: theme.infoSoft,
+        };
+    }
+}

package/dist/services/ps-menu-popup-service.d.ts

@@ -0,0 +1,6 @@
+import type { PsMenuAnchor } from '../interfaces/ps-menu-anchor';
+import type { PsMenuPopupLayout } from '../interfaces/ps-menu-popup-layout';
+import type { PsMenuPopupWindow } from '../interfaces/ps-menu-popup-window';
+export declare class PsMenuPopupService {
+    static layout(anchor: PsMenuAnchor, window: PsMenuPopupWindow, contentHeight: number, contentWidth: number, isFullWidth: boolean): PsMenuPopupLayout;
+}

package/dist/services/ps-menu-popup-service.js

@@ -0,0 +1,23 @@
+import { PsMenuPopupConfig } from '../constants/ps-menu-popup-config';
+export class PsMenuPopupService {
+    static layout(anchor, window, contentHeight, contentWidth, isFullWidth) {
+        const margin = PsMenuPopupConfig.edgeMargin;
+        const gap = PsMenuPopupConfig.anchorGap;
+        const width = isFullWidth ? anchor.width : undefined;
+        const menuWidth = width === undefined ? contentWidth : width;
+        const below = window.height - (anchor.y + anchor.height) - gap - margin;
+        const above = anchor.y - gap - margin;
+        const isBelow = contentHeight <= below || below >= above;
+        const room = isBelow ? below : above;
+        const height = Math.min(contentHeight, Math.max(room, 0));
+        const top = isBelow ? anchor.y + anchor.height + gap : anchor.y - gap - height;
+        const alignedRight = anchor.x + menuWidth > window.width - margin;
+        const left = alignedRight ? anchor.x + anchor.width - menuWidth : anchor.x;
+        return {
+            left: Math.max(margin, Math.min(left, window.width - margin - menuWidth)),
+            maxHeight: Math.max(room, 0),
+            top,
+            width,
+        };
+    }
+}

package/dist/services/ps-mobile-theme-service.d.ts

@@ -1,5 +1,5 @@
 import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
 import type { PsMobileThemeInput } from '../interfaces/ps-mobile-theme-input';
 export declare class PsMobileThemeService {
-    static create({ chart, hasHaptics, isDark, isReduceMotion, primary, primaryContrast, secondary, }: PsMobileThemeInput): PsMobileTheme;
+    static create({ chart, hasBrandSecondary, hasHaptics, isBrandChart, isDark, isReduceMotion, primary, primaryContrast, secondary, }: PsMobileThemeInput): PsMobileTheme;
 }

package/dist/services/ps-mobile-theme-service.js

@@ -1,7 +1,8 @@
 import { PallasoftThemeService } from '@pallasoft/ps-design-system';
 import { PsFontConfig } from '../constants/ps-font-config';
+import { PsChartBrandService } from './ps-chart-brand-service';
 export class PsMobileThemeService {
-    static create({ chart, hasHaptics, isDark, isReduceMotion, primary, primaryContrast, secondary, }) {
+    static create({ chart, hasBrandSecondary, hasHaptics, isBrandChart, isDark, isReduceMotion, primary, primaryContrast, secondary, }) {
         const tokens = PallasoftThemeService.build({
             primary,
             primaryContrast,
@@ -12,7 +13,11 @@ export class PsMobileThemeService {
             accent: tokens.accent,
             accentSoft: tokens.accentSoft,
             background: tokens.background,
-            chart: chart === undefined || chart.length === 0 ? tokens.chart : chart,
+            chart: chart !== undefined && chart.length > 0
+                ? chart
+                : isBrandChart === true
+                    ? PsChartBrandService.series(hasBrandSecondary === true ? [tokens.primary, tokens.secondary] : [tokens.primary])
+                    : tokens.chart,
             danger: tokens.danger,
             dangerSoft: tokens.dangerSoft,
             dangerText: tokens.dangerText,

package/dist/services/ps-navigation-theme-service.d.ts

@@ -0,0 +1,5 @@
+import type { Theme } from 'expo-router';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsNavigationThemeService {
+    static from(theme: PsMobileTheme): Theme;
+}

package/dist/services/ps-navigation-theme-service.js

@@ -0,0 +1,21 @@
+export class PsNavigationThemeService {
+    static from(theme) {
+        return {
+            colors: {
+                background: theme.background,
+                border: theme.line,
+                card: theme.background,
+                notification: theme.danger,
+                primary: theme.primaryText,
+                text: theme.ink,
+            },
+            dark: theme.isDark,
+            fonts: {
+                bold: { fontFamily: theme.fonts.bold, fontWeight: '700' },
+                heavy: { fontFamily: theme.fonts.bold, fontWeight: '800' },
+                medium: { fontFamily: theme.fonts.medium, fontWeight: '500' },
+                regular: { fontFamily: theme.fonts.regular, fontWeight: '400' },
+            },
+        };
+    }
+}

package/dist/services/ps-pdf-native-service.d.ts

@@ -0,0 +1,8 @@
+import type { PsDocumentPageImage } from '../interfaces/ps-document-page-image';
+export declare class PsPdfNativeService {
+    static isAvailable(): boolean;
+    static page(filePath: string, page: number, maxWidth: number): Promise<PsDocumentPageImage>;
+    static pages(filePath: string, maxWidth: number): Promise<PsDocumentPageImage[]>;
+    private static require;
+    private static load;
+}

package/dist/services/ps-pdf-native-service.js

@@ -0,0 +1,33 @@
+import { PsDocumentPdfConfig } from '../constants/ps-document-pdf-config';
+export class PsPdfNativeService {
+    static isAvailable() {
+        return PsPdfNativeService.load() !== null;
+    }
+    static async page(filePath, page, maxWidth) {
+        return PsPdfNativeService.require().generate(filePath, page, {
+            maxWidth,
+            quality: PsDocumentPdfConfig.jpegQuality,
+        });
+    }
+    static async pages(filePath, maxWidth) {
+        return PsPdfNativeService.require().generateAllPages(filePath, {
+            maxWidth,
+            quality: PsDocumentPdfConfig.jpegQuality,
+        });
+    }
+    static require() {
+        const native = PsPdfNativeService.load();
+        if (native === null)
+            throw new Error(PsDocumentPdfConfig.unavailableError);
+        return native;
+    }
+    static load() {
+        try {
+            const loaded = require('react-native-pdf-thumbnail');
+            return typeof loaded.default.generate === 'function' ? loaded.default : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/services/ps-quick-action-service.d.ts

@@ -0,0 +1,9 @@
+import type { PsQuickAction } from '../interfaces/ps-quick-action';
+import type { PsQuickActionNative, PsQuickActionNativeItem } from '../interfaces/ps-quick-action-native';
+export declare class PsQuickActionService {
+    private static isInitialTaken;
+    static toNative(items: PsQuickAction[], os?: string): PsQuickActionNativeItem[];
+    static key(items: PsQuickAction[]): string;
+    static takeInitial(native: PsQuickActionNative): PsQuickActionNativeItem | null;
+    static load(): PsQuickActionNative | null;
+}

package/dist/services/ps-quick-action-service.js

@@ -0,0 +1,31 @@
+import { Platform } from 'react-native';
+import { PsQuickActionConfig } from '../constants/ps-quick-action-config';
+export class PsQuickActionService {
+    static toNative(items, os = Platform.OS) {
+        return items.map((item) => ({
+            icon: os === 'ios' ? `${PsQuickActionConfig.iosSymbolPrefix}${item.iosSymbol}` : item.androidIcon,
+            id: item.id,
+            title: item.title,
+            ...(item.subtitle === undefined ? {} : { subtitle: item.subtitle }),
+        }));
+    }
+    static key(items) {
+        return JSON.stringify(PsQuickActionService.toNative(items));
+    }
+    static takeInitial(native) {
+        if (PsQuickActionService.isInitialTaken || native.initial === undefined)
+            return null;
+        PsQuickActionService.isInitialTaken = true;
+        return native.initial;
+    }
+    static load() {
+        try {
+            const loaded = require('expo-quick-actions');
+            return typeof loaded.setItems === 'function' ? loaded : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+PsQuickActionService.isInitialTaken = false;

package/dist/services/ps-ripple-service.d.ts

@@ -0,0 +1,7 @@
+import type { PressableAndroidRippleConfig } from 'react-native';
+import { PsRippleKind } from '../constants/ps-ripple-kind';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsRippleService {
+    static resolve(theme: PsMobileTheme, kind: PsRippleKind): PressableAndroidRippleConfig;
+    private static color;
+}

package/dist/services/ps-ripple-service.js

@@ -0,0 +1,26 @@
+import { PsAndroidStateConfig } from '../constants/ps-android-state-config';
+import { PsRippleKind } from '../constants/ps-ripple-kind';
+import { PsMobileColorService } from './ps-mobile-color-service';
+export class PsRippleService {
+    static resolve(theme, kind) {
+        const isBorderless = kind === PsRippleKind.Borderless;
+        return {
+            borderless: isBorderless,
+            color: PsRippleService.color(theme, kind),
+            foreground: true,
+            radius: isBorderless ? PsAndroidStateConfig.iconRippleRadius : undefined,
+        };
+    }
+    static color(theme, kind) {
+        switch (kind) {
+            case PsRippleKind.OnPrimary:
+                return PsMobileColorService.withAlpha(theme.primaryContrast, PsAndroidStateConfig.rippleOnFillAlpha);
+            case PsRippleKind.OnDanger:
+                return PsMobileColorService.withAlpha(theme.white, PsAndroidStateConfig.rippleOnFillAlpha);
+            case PsRippleKind.Danger:
+                return PsMobileColorService.withAlpha(theme.danger, PsAndroidStateConfig.rippleAlpha);
+            default:
+                return PsMobileColorService.withAlpha(theme.primary, PsAndroidStateConfig.rippleAlpha);
+        }
+    }
+}

package/dist/services/ps-screen-service.d.ts

@@ -1,6 +1,8 @@
 import type { ViewStyle } from 'react-native';
 import type { PsScreenInsets } from '../interfaces/ps-screen-insets';
 export declare class PsScreenService {
-    static content(insets: PsScreenInsets, isIos: boolean, hasGutter: boolean, gap: number): ViewStyle;
+    static content(insets: PsScreenInsets, isIos: boolean, hasGutter: boolean, gap: number, extraBottom?: number): ViewStyle;
+    static bottomInset(navigationBar: number, hasTabBar: boolean, isTabBarHidden: boolean): number;
+    static topInset(statusBar: number, headerHeight: number | undefined): number;
     static statusBarScrim(top: number): ViewStyle;
 }

package/dist/services/ps-screen-service.js

@@ -1,14 +1,20 @@
 import { PsLayoutConfig } from '../constants/ps-layout-config';
 export class PsScreenService {
-    static content(insets, isIos, hasGutter, gap) {
+    static content(insets, isIos, hasGutter, gap, extraBottom = 0) {
         const gutter = hasGutter ? PsLayoutConfig.gutter : 0;
         return {
             gap,
-            paddingBottom: (isIos ? 0 : insets.bottom) + gutter,
+            paddingBottom: (isIos ? 0 : insets.bottom + extraBottom) + gutter,
             paddingHorizontal: gutter,
             paddingTop: (isIos ? 0 : insets.top) + gutter,
         };
     }
+    static bottomInset(navigationBar, hasTabBar, isTabBarHidden) {
+        return hasTabBar && !isTabBarHidden ? 0 : navigationBar;
+    }
+    static topInset(statusBar, headerHeight) {
+        return headerHeight === undefined || headerHeight <= 0 ? statusBar : 0;
+    }
     static statusBarScrim(top) {
         return { height: top, left: 0, position: 'absolute', right: 0, top: 0 };
     }

package/dist/services/ps-sheet-service.d.ts

@@ -3,6 +3,7 @@ import type { PsSheetAction } from '../interfaces/ps-sheet-action';
 import type { PsSheetLeadingKind } from '../interfaces/ps-sheet-leading-kind';
 export declare class PsSheetService {
     static maxHeight(windowHeight: number): number;
+    static handlesInset(os: string): boolean;
     static bottomPadding(isFloating: boolean, bottomInset: number): number;
     static fittedHeight(headerHeight: number, bodyHeight: number, windowHeight: number): number;
     static closeAction(label: string | undefined, onPress: () => void): PsSheetAction | undefined;

package/dist/services/ps-sheet-service.js

@@ -4,6 +4,9 @@ export class PsSheetService {
     static maxHeight(windowHeight) {
         return Math.floor(windowHeight * PsSheetConfig.maxHeightFraction);
     }
+    static handlesInset(os) {
+        return os === 'ios' || os === 'android';
+    }
     static bottomPadding(isFloating, bottomInset) {
         return PsLayoutConfig.sheetGutter + (isFloating ? 0 : bottomInset);
     }

package/dist/services/ps-stack-options-service.d.ts

@@ -0,0 +1,5 @@
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+import type { PsStackScreenOptions } from '../interfaces/ps-stack-screen-options';
+export declare class PsStackOptionsService {
+    static android(base: PsStackScreenOptions, theme: PsMobileTheme): PsStackScreenOptions;
+}

package/dist/services/ps-stack-options-service.js

@@ -0,0 +1,18 @@
+import { PsHeaderConfig } from '../constants/ps-header-config';
+export class PsStackOptionsService {
+    static android(base, theme) {
+        return {
+            ...base,
+            contentStyle: { backgroundColor: theme.background },
+            headerShadowVisible: false,
+            headerStyle: { backgroundColor: theme.background },
+            headerTintColor: theme.ink,
+            headerTitleAlign: 'left',
+            headerTitleStyle: {
+                color: theme.ink,
+                fontFamily: theme.fonts.semibold,
+                fontSize: PsHeaderConfig.titleSize,
+            },
+        };
+    }
+}

package/dist/services/ps-state-service.d.ts

@@ -0,0 +1,7 @@
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsStateService {
+    static pressedFill(theme: PsMobileTheme, base: string): string;
+    static headerFill(theme: PsMobileTheme, isPressed: boolean): string;
+    static disabledOpacity(): number;
+    static ringColor(theme: PsMobileTheme, hasError: boolean): string;
+}

package/dist/services/ps-state-service.js

@@ -0,0 +1,26 @@
+import { Platform } from 'react-native';
+import { PsAndroidStateConfig } from '../constants/ps-android-state-config';
+import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
+import { PsMobileColorService } from './ps-mobile-color-service';
+export class PsStateService {
+    static pressedFill(theme, base) {
+        if (Platform.OS === 'android')
+            return base;
+        return PsMobileColorService.withAlpha(theme.ink, PsMobileControlConfig.pressedAlpha);
+    }
+    static headerFill(theme, isPressed) {
+        if (Platform.OS === 'android')
+            return isPressed ? theme.primarySoftStrong : theme.primarySoft;
+        return PsMobileColorService.withAlpha(theme.ink, isPressed
+            ? PsMobileControlConfig.neutralAlpha + PsMobileControlConfig.pressedAlpha
+            : PsMobileControlConfig.neutralAlpha);
+    }
+    static disabledOpacity() {
+        return Platform.OS === 'android'
+            ? PsAndroidStateConfig.disabledContentAlpha
+            : PsMobileControlConfig.disabledOpacity;
+    }
+    static ringColor(theme, hasError) {
+        return Platform.OS === 'android' && hasError ? theme.danger : theme.primary;
+    }
+}

package/dist/services/ps-switcher-service.d.ts

@@ -0,0 +1,6 @@
+import type { PsSwitcherItem } from '../interfaces/ps-switcher-item';
+export declare class PsSwitcherService {
+    static filter(items: PsSwitcherItem[], query: string): PsSwitcherItem[];
+    static hasSearch(count: number): boolean;
+    static selected(items: PsSwitcherItem[], id: string): PsSwitcherItem | undefined;
+}

package/dist/services/ps-switcher-service.js

@@ -0,0 +1,15 @@
+import { PsSwitcherConfig } from '../constants/ps-switcher-config';
+export class PsSwitcherService {
+    static filter(items, query) {
+        const needle = query.trim().toLowerCase();
+        return needle === ''
+            ? items
+            : items.filter((item) => item.searchText.toLowerCase().includes(needle));
+    }
+    static hasSearch(count) {
+        return count > PsSwitcherConfig.searchThreshold;
+    }
+    static selected(items, id) {
+        return items.find((item) => item.id === id);
+    }
+}

package/dist/services/ps-tab-bar-style-service.d.ts

@@ -0,0 +1,5 @@
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+import type { PsTabBarStyle } from '../interfaces/ps-tab-bar-style';
+export declare class PsTabBarStyleService {
+    static resolve(theme: PsMobileTheme): PsTabBarStyle;
+}

package/dist/services/ps-tab-bar-style-service.js

@@ -0,0 +1,30 @@
+import { Platform } from 'react-native';
+import { PsAndroidStateConfig } from '../constants/ps-android-state-config';
+import { PsMobileColorService } from './ps-mobile-color-service';
+export class PsTabBarStyleService {
+    static resolve(theme) {
+        if (Platform.OS !== 'android')
+            return { tintColor: theme.primaryText };
+        return {
+            backgroundColor: theme.surface,
+            badgeBackgroundColor: theme.danger,
+            badgeTextColor: theme.white,
+            iconColor: { default: theme.muted, selected: theme.primaryText },
+            indicatorColor: theme.primarySoftStrong,
+            labelStyle: {
+                default: {
+                    color: theme.muted,
+                    fontFamily: theme.fonts.medium,
+                    fontSize: PsAndroidStateConfig.tabLabelSize,
+                },
+                selected: {
+                    color: theme.primaryText,
+                    fontFamily: theme.fonts.semibold,
+                    fontSize: PsAndroidStateConfig.tabLabelSize,
+                },
+            },
+            rippleColor: PsMobileColorService.withAlpha(theme.primary, PsAndroidStateConfig.rippleAlpha),
+            tintColor: theme.primaryText,
+        };
+    }
+}

package/dist/services/ps-waterfall-service.d.ts

@@ -0,0 +1,10 @@
+import type { PsChartBarRect } from '../interfaces/ps-chart-bar-rect';
+import type { PsChartDomain } from '../interfaces/ps-chart-domain';
+import type { PsChartPlot } from '../interfaces/ps-chart-plot';
+import type { PsWaterfallDatum } from '../interfaces/ps-waterfall-datum';
+import type { PsWaterfallStep } from '../interfaces/ps-waterfall-step';
+export declare class PsWaterfallService {
+    static steps(data: PsWaterfallDatum[]): PsWaterfallStep[];
+    static values(steps: PsWaterfallStep[]): number[];
+    static rects(steps: PsWaterfallStep[], colors: string[], domain: PsChartDomain, plot: PsChartPlot): PsChartBarRect[];
+}

package/dist/services/ps-waterfall-service.js

@@ -0,0 +1,38 @@
+import { PsChartConfig } from '../constants/ps-chart-config';
+import { PsChartBarService } from './ps-chart-bar-service';
+import { PsChartScaleService } from './ps-chart-scale-service';
+export class PsWaterfallService {
+    static steps(data) {
+        let running = 0;
+        return data.map((datum) => {
+            const value = Number.isFinite(datum.value) ? datum.value : 0;
+            if (datum.isTotal === true) {
+                running = value;
+                return { end: value, isTotal: true, label: datum.label, start: 0, value };
+            }
+            const start = running;
+            running += value;
+            return { end: running, isTotal: false, label: datum.label, start, value };
+        });
+    }
+    static values(steps) {
+        return steps.flatMap((step) => [step.start, step.end]);
+    }
+    static rects(steps, colors, domain, plot) {
+        const slot = PsChartBarService.slot(steps.length, plot);
+        const width = slot * (1 - PsChartConfig.barGapRatio);
+        return steps.map((step, row) => {
+            const from = PsChartScaleService.y(step.start, domain, plot);
+            const to = PsChartScaleService.y(step.end, domain, plot);
+            return {
+                color: step.isTotal ? colors[2] : step.value < 0 ? colors[1] : colors[0],
+                height: Math.abs(to - from),
+                id: `${row}:${step.label}`,
+                isNegative: step.end < step.start,
+                width,
+                x: plot.left + row * slot + (slot * PsChartConfig.barGapRatio) / 2,
+                y: Math.min(from, to),
+            };
+        });
+    }
+}