@pallasoft/ps-mobile-components 1.2.0 → 1.4.0

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-menu-tile-service.d.ts

@@ -0,0 +1,16 @@
+import type { PsActionMenuHeader } from '../interfaces/ps-action-menu-header';
+import type { PsActionMenuSection } from '../interfaces/ps-action-menu-section';
+import type { PsMenuItem } from '../interfaces/ps-menu-item';
+import type { PsMenuTileRequest } from '../interfaces/ps-menu-tile-request';
+export declare class PsMenuTileService {
+    static itemRequest(item: PsMenuItem): PsMenuTileRequest | null;
+    static headerRequest(header: PsActionMenuHeader | undefined): PsMenuTileRequest | null;
+    static requests(header: PsActionMenuHeader | undefined, sections: PsActionMenuSection[]): PsMenuTileRequest[];
+    static sections(sections: PsActionMenuSection[], tiles: Record<string, string>): PsActionMenuSection[];
+    static item(item: PsMenuItem, tiles: Record<string, string>): PsMenuItem;
+    static header(header: PsActionMenuHeader | undefined, tiles: Record<string, string>): PsActionMenuHeader | undefined;
+    static letter(value: string): string;
+    private static tile;
+    private static tree;
+    private static request;
+}

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

@@ -0,0 +1,70 @@
+import { PsActionMenuService } from './ps-action-menu-service';
+export class PsMenuTileService {
+    static itemRequest(item) {
+        if (!PsActionMenuService.hasAvatar(item))
+            return null;
+        const text = PsMenuTileService.letter(item.monogram === undefined ? item.label : item.monogram);
+        return PsMenuTileService.request('rounded', item.imageUri, text);
+    }
+    static headerRequest(header) {
+        if (header === undefined)
+            return null;
+        if (header.imageUri === undefined && header.initials === undefined)
+            return null;
+        return PsMenuTileService.request('circle', header.imageUri, header.initials === undefined ? '' : header.initials.trim().toUpperCase());
+    }
+    static requests(header, sections) {
+        const all = [
+            PsMenuTileService.headerRequest(header),
+            ...sections
+                .flatMap((section) => section.items.flatMap((item) => PsMenuTileService.tree(item)))
+                .map((item) => PsMenuTileService.itemRequest(item)),
+        ].filter((request) => request !== null);
+        return all.filter((request, index) => all.findIndex((other) => other.key === request.key) === index);
+    }
+    static sections(sections, tiles) {
+        return sections.map((section) => ({
+            ...section,
+            items: section.items.map((item) => PsMenuTileService.item(item, tiles)),
+        }));
+    }
+    static item(item, tiles) {
+        const children = item.children === undefined
+            ? undefined
+            : item.children.map((child) => PsMenuTileService.item(child, tiles));
+        const request = PsMenuTileService.itemRequest(item);
+        if (request === null)
+            return { ...item, children };
+        return {
+            ...item,
+            children,
+            imageUri: PsMenuTileService.tile(request, tiles),
+            monogram: item.monogram === undefined ? item.label : item.monogram,
+        };
+    }
+    static header(header, tiles) {
+        const request = PsMenuTileService.headerRequest(header);
+        if (header === undefined || request === null)
+            return header;
+        return { ...header, imageUri: PsMenuTileService.tile(request, tiles) };
+    }
+    static letter(value) {
+        return Array.from(value.trim()).slice(0, 1).join('').toUpperCase();
+    }
+    static tile(request, tiles) {
+        return request.key in tiles ? tiles[request.key] : undefined;
+    }
+    static tree(item) {
+        if (item.children === undefined)
+            return [item];
+        return [item, ...item.children.flatMap((child) => PsMenuTileService.tree(child))];
+    }
+    static request(shape, imageUri, text) {
+        return {
+            imageUri,
+            key: [shape, imageUri === undefined ? '' : imageUri, text].join('|'),
+            shape,
+            text,
+        };
+    }
+}

package/dist/services/ps-menu-tile-style-service.d.ts

@@ -0,0 +1,4 @@
+import type { ViewStyle } from 'react-native';
+export declare class PsMenuTileStyleService {
+    static canvas(): ViewStyle;
+}

package/dist/services/ps-menu-tile-style-service.js

@@ -0,0 +1,5 @@
+export class PsMenuTileStyleService {
+    static canvas() {
+        return { left: 0, opacity: 0, position: 'absolute', top: 0 };
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { PsMobileBrandColors } from '../interfaces/ps-mobile-brand-colors';
+import type { PsMobileBrandInput } from '../interfaces/ps-mobile-brand-input';
+export declare class PsMobileBrandService {
+    static resolve({ primaryColor, primaryContrastColor, product, secondaryColor, }: PsMobileBrandInput): PsMobileBrandColors;
+}

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

@@ -0,0 +1,24 @@
+import { PallasoftColor, PallasoftProductBrandService } from '@pallasoft/ps-design-system';
+export class PsMobileBrandService {
+    static resolve({ primaryColor, primaryContrastColor, product, secondaryColor, }) {
+        const brand = product === undefined ? null : PallasoftProductBrandService.colors(product);
+        if (primaryColor === undefined) {
+            return brand === null
+                ? {
+                    primary: PallasoftColor.Accent,
+                    primaryContrast: primaryContrastColor,
+                    secondary: secondaryColor,
+                }
+                : {
+                    primary: brand.primary,
+                    primaryContrast: brand.primaryContrast,
+                    secondary: secondaryColor === undefined ? brand.secondary : secondaryColor,
+                };
+        }
+        return {
+            primary: primaryColor,
+            primaryContrast: primaryContrastColor,
+            secondary: secondaryColor === undefined && brand !== null ? brand.secondary : secondaryColor,
+        };
+    }
+}

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

@@ -1,7 +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;
-    private static light;
-    private static dark;
+    static create({ chart, hasBrandSecondary, hasHaptics, isBrandChart, isDark, isReduceMotion, primary, primaryContrast, secondary, }: PsMobileThemeInput): PsMobileTheme;
 }

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

@@ -1,104 +1,79 @@
-import { PallasoftBrandColorService, PallasoftChartColor, PallasoftColor, PallasoftDarkChartColor, PallasoftDarkColor, } from '@pallasoft/ps-design-system';
+import { PallasoftThemeService } from '@pallasoft/ps-design-system';
 import { PsFontConfig } from '../constants/ps-font-config';
-import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
-import { PsMobileColorService } from './ps-mobile-color-service';
+import { PsChartBrandService } from './ps-chart-brand-service';
 export class PsMobileThemeService {
-    static create({ chart, hasHaptics, isDark, isReduceMotion, primary, primaryContrast, secondary, }) {
-        const scheme = isDark
-            ? PsMobileThemeService.dark(primary, primaryContrast)
-            : PsMobileThemeService.light(primary, primaryContrast);
-        const base = {
-            ...scheme,
-            chart: chart === undefined || chart.length === 0 ? scheme.chart : chart,
-            hasHaptics: hasHaptics === undefined ? true : hasHaptics,
-            isReduceMotion: isReduceMotion === undefined ? false : isReduceMotion,
-        };
-        const fallback = isDark ? PallasoftDarkColor.Accent : PallasoftColor.Accent;
-        const palette = PallasoftBrandColorService.palette(secondary === undefined ? fallback : secondary);
-        if (palette === null)
-            return base;
-        return {
-            ...base,
-            secondary: palette.primary,
-            secondaryContrast: palette.contrast,
-            secondarySoft: isDark ? palette.softDark : palette.softLight,
-        };
-    }
-    static light(primary, primaryContrast) {
-        return {
-            accent: PallasoftColor.Accent,
-            accentSoft: PallasoftColor.Mist,
-            background: PallasoftColor.Background,
-            chart: [
-                PallasoftChartColor.Chart1,
-                PallasoftChartColor.Chart2,
-                PallasoftChartColor.Chart3,
-                PallasoftChartColor.Chart4,
-                PallasoftChartColor.Chart5,
-            ],
-            danger: PallasoftColor.Danger,
-            dangerSoft: PallasoftColor.DangerSoft,
-            fonts: PsFontConfig,
-            ink: PallasoftColor.Ink,
-            hasHaptics: true,
-            isDark: false,
-            isReduceMotion: false,
-            line: PallasoftColor.Line,
-            muted: PallasoftColor.Muted,
-            overlay: PsMobileColorService.withAlpha(PallasoftColor.Ink, PsMobileControlConfig.overlayAlpha),
+    static create({ chart, hasBrandSecondary, hasHaptics, isBrandChart, isDark, isReduceMotion, primary, primaryContrast, secondary, }) {
+        const tokens = PallasoftThemeService.build({
             primary,
             primaryContrast,
-            primarySoft: PsMobileColorService.withAlpha(primary, PsMobileControlConfig.softAlphaLight),
-            secondary: PallasoftColor.Accent,
-            secondaryContrast: PallasoftColor.White,
-            secondarySoft: PallasoftColor.Mist,
-            skeletonBase: PsMobileColorService.withAlpha(PallasoftColor.Ink, PsMobileControlConfig.skeletonBaseAlpha.light),
-            skeletonSweep: PsMobileColorService.withAlpha(PallasoftColor.Ink, PsMobileControlConfig.skeletonSweepAlpha.light),
-            success: PallasoftColor.Success,
-            successSoft: PallasoftColor.SuccessSoft,
-            surface: PallasoftColor.White,
-            warning: PallasoftColor.Warning,
-            warningSoft: PallasoftColor.WarningSoft,
-            white: PallasoftColor.White,
-        };
-    }
-    static dark(primary, primaryContrast) {
-        const alpha = PsMobileControlConfig.softAlphaDark;
+            scheme: isDark ? 'dark' : 'light',
+            secondary,
+        });
         return {
-            accent: PallasoftDarkColor.Accent,
-            accentSoft: PallasoftDarkColor.AccentSoft,
-            background: PallasoftDarkColor.Background,
-            chart: [
-                PallasoftDarkChartColor.Chart1,
-                PallasoftDarkChartColor.Chart2,
-                PallasoftDarkChartColor.Chart3,
-                PallasoftDarkChartColor.Chart4,
-                PallasoftDarkChartColor.Chart5,
-            ],
-            danger: PallasoftDarkColor.Danger,
-            dangerSoft: PallasoftDarkColor.DangerSoft,
+            accent: tokens.accent,
+            accentSoft: tokens.accentSoft,
+            background: tokens.background,
+            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,
             fonts: PsFontConfig,
-            ink: PallasoftDarkColor.Ink,
-            hasHaptics: true,
-            isDark: true,
-            isReduceMotion: false,
-            line: PallasoftDarkColor.Line,
-            muted: PallasoftDarkColor.Muted,
-            overlay: PsMobileColorService.withAlpha(PallasoftDarkColor.Background, PsMobileControlConfig.overlayAlphaDark),
-            primary,
-            primaryContrast,
-            primarySoft: PsMobileColorService.withAlpha(primary, alpha),
-            secondary: PallasoftDarkColor.Accent,
-            secondaryContrast: PallasoftDarkColor.White,
-            secondarySoft: PallasoftDarkColor.AccentSoft,
-            skeletonBase: PsMobileColorService.withAlpha(PallasoftDarkColor.Ink, PsMobileControlConfig.skeletonBaseAlpha.dark),
-            skeletonSweep: PsMobileColorService.withAlpha(PallasoftDarkColor.Ink, PsMobileControlConfig.skeletonSweepAlpha.dark),
-            success: PallasoftDarkColor.Success,
-            successSoft: PallasoftDarkColor.SuccessSoft,
-            surface: PallasoftDarkColor.Surface,
-            warning: PallasoftDarkColor.Warning,
-            warningSoft: PallasoftDarkColor.WarningSoft,
-            white: PallasoftDarkColor.White,
+            hasHaptics: hasHaptics === undefined ? true : hasHaptics,
+            info: tokens.info,
+            infoSoft: tokens.infoSoft,
+            infoText: tokens.infoText,
+            ink: tokens.ink,
+            isDark,
+            isReduceMotion: isReduceMotion === undefined ? false : isReduceMotion,
+            line: tokens.line,
+            muted: tokens.muted,
+            overlay: tokens.overlay,
+            primary: tokens.primary,
+            primary100: tokens.primary100,
+            primary200: tokens.primary200,
+            primary300: tokens.primary300,
+            primary400: tokens.primary400,
+            primary50: tokens.primary50,
+            primary500: tokens.primary500,
+            primary600: tokens.primary600,
+            primary700: tokens.primary700,
+            primary800: tokens.primary800,
+            primary900: tokens.primary900,
+            primaryContrast: tokens.primaryContrast,
+            primaryPressed: tokens.primaryPressed,
+            primarySoft: tokens.primarySoft,
+            primarySoftStrong: tokens.primarySoftStrong,
+            primaryText: tokens.primaryText,
+            secondary: tokens.secondary,
+            secondary100: tokens.secondary100,
+            secondary200: tokens.secondary200,
+            secondary300: tokens.secondary300,
+            secondary400: tokens.secondary400,
+            secondary50: tokens.secondary50,
+            secondary500: tokens.secondary500,
+            secondary600: tokens.secondary600,
+            secondary700: tokens.secondary700,
+            secondary800: tokens.secondary800,
+            secondary900: tokens.secondary900,
+            secondaryContrast: tokens.secondaryContrast,
+            secondaryPressed: tokens.secondaryPressed,
+            secondarySoft: tokens.secondarySoft,
+            secondarySoftStrong: tokens.secondarySoftStrong,
+            secondaryText: tokens.secondaryText,
+            skeletonBase: tokens.skeletonBase,
+            skeletonSweep: tokens.skeletonSweep,
+            success: tokens.success,
+            successSoft: tokens.successSoft,
+            successText: tokens.successText,
+            surface: tokens.surface,
+            warning: tokens.warning,
+            warningSoft: tokens.warningSoft,
+            warningText: tokens.warningText,
+            white: tokens.white,
         };
     }
 }

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-option-picker-service.d.ts

@@ -0,0 +1,8 @@
+import type { PsOptionPickerOption } from '../components/ps-option-picker/ps-option-picker-props';
+export interface PsOptionPickerResult {
+    hasMore: boolean;
+    options: PsOptionPickerOption[];
+}
+export declare class PsOptionPickerService {
+    static visible(options: PsOptionPickerOption[], search: string, limit: number): PsOptionPickerResult;
+}

package/dist/services/ps-option-picker-service.js

@@ -0,0 +1,10 @@
+export class PsOptionPickerService {
+    static visible(options, search, limit) {
+        const needle = search.trim().toLowerCase();
+        const matches = needle === ''
+            ? options
+            : options.filter((option) => option.label.toLowerCase().includes(needle) ||
+                (option.subtitle !== undefined && option.subtitle.toLowerCase().includes(needle)));
+        return { hasMore: matches.length > limit, options: matches.slice(0, limit) };
+    }
+}

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-selection-service.d.ts

@@ -0,0 +1,5 @@
+export declare class PsSelectionService {
+    static toggle(selectedIds: string[], id: string): string[];
+    static isAll(selectableIds: string[], selectedIds: string[]): boolean;
+    static toggleAll(selectableIds: string[], selectedIds: string[]): string[];
+}

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

@@ -0,0 +1,13 @@
+export class PsSelectionService {
+    static toggle(selectedIds, id) {
+        return selectedIds.includes(id)
+            ? selectedIds.filter((selectedId) => selectedId !== id)
+            : [...selectedIds, id];
+    }
+    static isAll(selectableIds, selectedIds) {
+        return selectableIds.length > 0 && selectableIds.every((id) => selectedIds.includes(id));
+    }
+    static toggleAll(selectableIds, selectedIds) {
+        return PsSelectionService.isAll(selectableIds, selectedIds) ? [] : [...selectableIds];
+    }
+}

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

@@ -1,10 +1,16 @@
+import type { ViewStyle } from 'react-native';
 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;
     static isActionInactive(action: PsSheetAction): boolean;
     static actionOpacity(action: PsSheetAction, isPressed: boolean): number;
+    static trailing(action: PsSheetAction | null | undefined, closeLabel: string | undefined, onClose: () => void): PsSheetAction | undefined;
+    static leadingIconStyle(kind: PsSheetLeadingKind): ViewStyle;
+    static grownHeight(previous: number, measured: number, isOpen: boolean): number;
     static shouldClose(isPresented: boolean, isOpen: boolean, isDismissBlocked: boolean): boolean;
 }