@pallasoft/ps-mobile-components 1.3.0 → 1.5.0

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

@@ -0,0 +1,40 @@
+import { PsDocumentFileConfig } from '../constants/ps-document-file-config';
+import { PsDocumentLoadStatus } from '../constants/ps-document-load-status';
+import { PsDocumentPdfConfig } from '../constants/ps-document-pdf-config';
+import { PsDocumentFileService } from './ps-document-file-service';
+import { PsPdfNativeService } from './ps-pdf-native-service';
+export class PsDocumentPdfService {
+    static isAvailable() {
+        return PsPdfNativeService.isAvailable() && PsDocumentFileService.isAvailable();
+    }
+    static async cover(source, name) {
+        return PsDocumentPdfService.render(source, name, 'cover', (path) => PsPdfNativeService.page(path, 0, PsDocumentPdfConfig.coverMaxWidth).then((image) => [image]));
+    }
+    static async pages(source, name) {
+        return PsDocumentPdfService.render(source, name, 'pages', (path) => PsPdfNativeService.pages(path, PsDocumentPdfConfig.pageMaxWidth));
+    }
+    static clear() {
+        PsDocumentPdfService.rendered.clear();
+    }
+    static async render(source, name, scope, draw) {
+        if (!PsDocumentPdfService.isAvailable())
+            return { pages: [], status: PsDocumentLoadStatus.Unavailable };
+        const key = `${scope}|${source.uri}`;
+        const cached = PsDocumentPdfService.rendered.get(key);
+        if (cached !== undefined)
+            return cached;
+        const path = await PsDocumentFileService.local(source, name, PsDocumentFileConfig.pdfExtension);
+        if (path === null)
+            return { pages: [], status: PsDocumentLoadStatus.Failed };
+        try {
+            const pages = await draw(path);
+            const state = { pages, status: PsDocumentLoadStatus.Ready };
+            PsDocumentPdfService.rendered.set(key, state);
+            return state;
+        }
+        catch {
+            return { pages: [], status: PsDocumentLoadStatus.Failed };
+        }
+    }
+}
+PsDocumentPdfService.rendered = new Map();

package/dist/services/ps-document-text-service.d.ts

@@ -0,0 +1,5 @@
+import type { PsDocumentItem } from '../interfaces/ps-document-item';
+export declare class PsDocumentTextService {
+    static needsLoad(item: PsDocumentItem): boolean;
+    static load(item: PsDocumentItem): Promise<string | null>;
+}

package/dist/services/ps-document-text-service.js

@@ -0,0 +1,14 @@
+import { PsDocumentFileConfig } from '../constants/ps-document-file-config';
+import { PsDocumentKind } from '../constants/ps-document-kind';
+import { PsDocumentFileService } from './ps-document-file-service';
+export class PsDocumentTextService {
+    static needsLoad(item) {
+        return item.kind === PsDocumentKind.Text && item.text === null && item.source !== null;
+    }
+    static async load(item) {
+        if (item.source === null)
+            return null;
+        const uri = await PsDocumentFileService.local(item.source, item.name, PsDocumentFileConfig.textExtension);
+        return uri === null ? null : PsDocumentFileService.readText(uri);
+    }
+}

package/dist/services/ps-document-viewer-entry-service.d.ts

@@ -0,0 +1,11 @@
+import type { PsDocumentItem } from '../interfaces/ps-document-item';
+import type { PsDocumentPdfState } from '../interfaces/ps-document-pdf-state';
+import type { PsDocumentViewerEntry } from '../interfaces/ps-document-viewer-entry';
+export declare class PsDocumentViewerEntryService {
+    static entries(items: PsDocumentItem[], states: Record<string, PsDocumentPdfState>): PsDocumentViewerEntry[];
+    static startIndex(items: PsDocumentItem[], entries: PsDocumentViewerEntry[], initialIndex: number): number;
+    static resolveIndex(current: PsDocumentViewerEntry | null, entries: PsDocumentViewerEntry[], fallbackIndex: number): number;
+    static hasStrip(items: PsDocumentItem[], entries: PsDocumentViewerEntry[]): boolean;
+    static pdfKey(items: PsDocumentItem[]): string;
+    private static expand;
+}

package/dist/services/ps-document-viewer-entry-service.js

@@ -0,0 +1,72 @@
+import { PsDocumentConfig } from '../constants/ps-document-config';
+import { PsDocumentKind } from '../constants/ps-document-kind';
+import { PsDocumentLoadStatus } from '../constants/ps-document-load-status';
+import { PsDocumentPdfConfig } from '../constants/ps-document-pdf-config';
+import { PsDocumentPagerService } from './ps-document-pager-service';
+export class PsDocumentViewerEntryService {
+    static entries(items, states) {
+        return items.flatMap((item) => PsDocumentViewerEntryService.expand(item, states[item.id]));
+    }
+    static startIndex(items, entries, initialIndex) {
+        const item = items[PsDocumentPagerService.clampIndex(initialIndex, items.length)];
+        if (item === undefined)
+            return 0;
+        const found = entries.findIndex((entry) => entry.sourceId === item.id);
+        return found < 0 ? 0 : found;
+    }
+    static resolveIndex(current, entries, fallbackIndex) {
+        if (current !== null) {
+            const sameEntry = entries.findIndex((entry) => entry.id === current.id);
+            if (sameEntry >= 0)
+                return sameEntry;
+            const sameSource = entries.findIndex((entry) => entry.sourceId === current.sourceId);
+            if (sameSource >= 0)
+                return sameSource;
+        }
+        return PsDocumentPagerService.clampIndex(fallbackIndex, entries.length);
+    }
+    static hasStrip(items, entries) {
+        return (PsDocumentPagerService.hasMany(entries.length) &&
+            items.some((item) => item.kind === PsDocumentKind.Pdf));
+    }
+    static pdfKey(items) {
+        return items
+            .filter((item) => item.kind === PsDocumentKind.Pdf && item.source !== null)
+            .map((item) => `${item.id}${PsDocumentConfig.keySeparator}${item.source?.uri}`)
+            .join(PsDocumentConfig.keyJoin);
+    }
+    static expand(item, state) {
+        if (item.kind !== PsDocumentKind.Pdf)
+            return [{ id: item.id, item, sourceId: item.id, status: PsDocumentLoadStatus.Ready }];
+        if (item.source === null)
+            return [{ id: item.id, item, sourceId: item.id, status: PsDocumentLoadStatus.Unavailable }];
+        if (state === undefined)
+            return [{ id: item.id, item, sourceId: item.id, status: PsDocumentLoadStatus.Loading }];
+        if (state.status !== PsDocumentLoadStatus.Ready || state.pages.length === 0)
+            return [
+                {
+                    id: item.id,
+                    item,
+                    sourceId: item.id,
+                    status: state.status === PsDocumentLoadStatus.Ready
+                        ? PsDocumentLoadStatus.Failed
+                        : state.status,
+                },
+            ];
+        return state.pages.map((page, index) => {
+            const id = `${item.id}${PsDocumentPdfConfig.pageIdSeparator}${index + 1}`;
+            return {
+                id,
+                item: {
+                    id,
+                    kind: PsDocumentKind.Image,
+                    name: item.name,
+                    source: { headers: {}, uri: page.uri },
+                    text: null,
+                },
+                sourceId: item.id,
+                status: PsDocumentLoadStatus.Ready,
+            };
+        });
+    }
+}

package/dist/services/ps-list-row-style-service.js

@@ -1,11 +1,8 @@
-import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
-import { PsMobileColorService } from './ps-mobile-color-service';
+import { PsStateService } from './ps-state-service';
 export class PsListRowStyleService {
     static background(isSelected, isPressed, theme) {
         if (isSelected)
             return isPressed ? theme.primarySoftStrong : theme.primarySoft;
-        return isPressed
-            ? PsMobileColorService.withAlpha(theme.ink, PsMobileControlConfig.pressedAlpha)
-            : theme.surface;
+        return isPressed ? PsStateService.pressedFill(theme, theme.surface) : theme.surface;
     }
 }

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;
+}