@pallasoft/ps-mobile-components 0.0.0-stage → 1.1.0

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

@@ -0,0 +1,7 @@
+export declare class PsDocumentPagerService {
+    static clampIndex(index: number, count: number): number;
+    static counter(index: number, count: number): string;
+    static hasMany(count: number): boolean;
+    static offset(index: number, width: number): number;
+    static pageIndex(offsetX: number, width: number, count: number): number;
+}

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

@@ -0,0 +1,18 @@
+import { PsDocumentConfig } from '../constants/ps-document-config';
+export class PsDocumentPagerService {
+    static clampIndex(index, count) {
+        return Math.max(0, Math.min(count - 1, index));
+    }
+    static counter(index, count) {
+        return `${index + 1}${PsDocumentConfig.counterSeparator}${count}`;
+    }
+    static hasMany(count) {
+        return count > 1;
+    }
+    static offset(index, width) {
+        return index * width;
+    }
+    static pageIndex(offsetX, width, count) {
+        return width <= 0 ? 0 : PsDocumentPagerService.clampIndex(Math.round(offsetX / width), count);
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { PsDocumentScannerOptions } from '../interfaces/ps-document-scanner-options';
+import type { PsScannedFile } from '../interfaces/ps-scanned-file';
+export declare class PsDocumentScannerService {
+    static isAvailable(): boolean;
+    static scan(options: PsDocumentScannerOptions): Promise<PsScannedFile[]>;
+    static toFiles(uris: string[], fileName?: string): PsScannedFile[];
+    static quality(jpegQuality?: number): number;
+    static pageLimit(maxPages?: number): number | null;
+    private static load;
+}

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

@@ -0,0 +1,48 @@
+import { PsDocumentScannerConfig } from '../constants/ps-document-scanner-config';
+export class PsDocumentScannerService {
+    static isAvailable() {
+        return PsDocumentScannerService.load() !== null;
+    }
+    static async scan(options) {
+        const native = PsDocumentScannerService.load();
+        if (native === null)
+            return [];
+        const maxPages = PsDocumentScannerService.pageLimit(options.maxPages);
+        const response = await native.scanDocument({
+            croppedImageQuality: PsDocumentScannerService.quality(options.jpegQuality),
+            ...(maxPages === null ? {} : { maxNumDocuments: maxPages }),
+        });
+        if (response.status !== PsDocumentScannerConfig.successStatus)
+            return [];
+        const uris = response.scannedImages === undefined ? [] : response.scannedImages;
+        const limited = maxPages === null ? uris : uris.slice(0, maxPages);
+        return PsDocumentScannerService.toFiles(limited, options.fileName);
+    }
+    static toFiles(uris, fileName) {
+        const base = fileName === undefined || fileName === ''
+            ? PsDocumentScannerConfig.defaultFileName
+            : fileName;
+        return uris.map((uri, index) => ({
+            name: `${base}-${index + 1}.${PsDocumentScannerConfig.fileExtension}`,
+            type: PsDocumentScannerConfig.fileType,
+            uri,
+        }));
+    }
+    static quality(jpegQuality) {
+        if (jpegQuality === undefined)
+            return PsDocumentScannerConfig.defaultJpegQuality;
+        return Math.min(PsDocumentScannerConfig.maxJpegQuality, Math.max(PsDocumentScannerConfig.minJpegQuality, Math.round(jpegQuality)));
+    }
+    static pageLimit(maxPages) {
+        return maxPages === undefined || maxPages < 1 ? null : Math.floor(maxPages);
+    }
+    static load() {
+        try {
+            const loaded = require('react-native-document-scanner-plugin');
+            return typeof loaded.default.scanDocument === 'function' ? loaded.default : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+export declare class PsDocumentZoomService {
+    static clampAxis(value: number, container: number, scale: number): number;
+    static clampScale(scale: number): number;
+    static dragOffset(translationY: number): number;
+    static focalOffset(tap: number, container: number, scale: number): number;
+    static isZoomed(scale: number): boolean;
+    static nextTapScale(scale: number): number;
+    static shouldDismiss(translationY: number, velocityY: number): boolean;
+}

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

@@ -0,0 +1,28 @@
+import { PsDocumentConfig } from '../constants/ps-document-config';
+export class PsDocumentZoomService {
+    static clampAxis(value, container, scale) {
+        const limit = (container * (scale - 1)) / 2;
+        return Math.min(limit, Math.max(-limit, value));
+    }
+    static clampScale(scale) {
+        return Math.min(PsDocumentConfig.maxZoom, Math.max(PsDocumentConfig.minZoom, scale));
+    }
+    static dragOffset(translationY) {
+        return Math.max(0, translationY);
+    }
+    static focalOffset(tap, container, scale) {
+        return PsDocumentZoomService.clampAxis((container / 2 - tap) * (scale - 1), container, scale);
+    }
+    static isZoomed(scale) {
+        return scale > PsDocumentConfig.minZoom + PsDocumentConfig.scaleEpsilon;
+    }
+    static nextTapScale(scale) {
+        return PsDocumentZoomService.isZoomed(scale)
+            ? PsDocumentConfig.minZoom
+            : PsDocumentConfig.doubleTapScale;
+    }
+    static shouldDismiss(translationY, velocityY) {
+        return (translationY >= PsDocumentConfig.dismissDistance ||
+            (translationY > 0 && velocityY >= PsDocumentConfig.dismissVelocity));
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { PsFilterBarLabels } from '../interfaces/ps-filter-bar-labels';
+import type { PsFilterChip } from '../interfaces/ps-filter-chip';
+import type { PsFilterGroup } from '../interfaces/ps-filter-group';
+import type { PsFilterOption } from '../interfaces/ps-filter-option';
+export declare class PsFilterService {
+    static values(groups: PsFilterGroup[]): Record<string, string>;
+    static cleared(groups: PsFilterGroup[]): Record<string, string>;
+    static chips(groups: PsFilterGroup[]): PsFilterChip[];
+    static without(groups: PsFilterGroup[], groupId: string): Record<string, string>;
+    static menuOptions(group: PsFilterGroup, labels: PsFilterBarLabels): PsFilterOption[];
+    static chipLabel(group: PsFilterGroup): string;
+}

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

@@ -0,0 +1,28 @@
+export class PsFilterService {
+    static values(groups) {
+        return Object.fromEntries(groups.map((group) => [group.id, group.value]));
+    }
+    static cleared(groups) {
+        return Object.fromEntries(groups.map((group) => [group.id, '']));
+    }
+    static chips(groups) {
+        return groups.flatMap((group) => {
+            const option = group.options.find((item) => item.value === group.value);
+            return group.value === '' || option === undefined
+                ? []
+                : [{ groupId: group.id, label: `${group.label}: ${option.label}` }];
+        });
+    }
+    static without(groups, groupId) {
+        return { ...PsFilterService.values(groups), [groupId]: '' };
+    }
+    static menuOptions(group, labels) {
+        return [{ label: labels.all, value: '' }, ...group.options];
+    }
+    static chipLabel(group) {
+        const option = group.options.find((item) => item.value === group.value);
+        return group.value === '' || option === undefined
+            ? group.label
+            : `${group.label}: ${option.label}`;
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { PsHapticKind } from '../interfaces/ps-haptic-kind';
+export declare class PsHapticService {
+    static play(kind: PsHapticKind, isEnabled: boolean): void;
+    private static run;
+}

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

@@ -0,0 +1,26 @@
+import * as Haptics from 'expo-haptics';
+export class PsHapticService {
+    static play(kind, isEnabled) {
+        if (!isEnabled)
+            return;
+        void PsHapticService.run(kind).catch(() => undefined);
+    }
+    static run(kind) {
+        switch (kind) {
+            case 'selection':
+                return Haptics.selectionAsync();
+            case 'light':
+                return Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light);
+            case 'medium':
+                return Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium);
+            case 'heavy':
+                return Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Heavy);
+            case 'success':
+                return Haptics.notificationAsync(Haptics.NotificationFeedbackType.Success);
+            case 'warning':
+                return Haptics.notificationAsync(Haptics.NotificationFeedbackType.Warning);
+            default:
+                return Haptics.notificationAsync(Haptics.NotificationFeedbackType.Error);
+        }
+    }
+}

package/dist/services/ps-icon-fit-service.d.ts

@@ -0,0 +1,4 @@
+export declare class PsIconFitService {
+    static transform(iconKey: string): string | undefined;
+    static strokeWidth(iconKey: string): number;
+}

package/dist/services/ps-icon-fit-service.js

@@ -0,0 +1,16 @@
+import { PsIconConfig, PsIconFit } from '@pallasoft/ps-icons';
+export class PsIconFitService {
+    static transform(iconKey) {
+        const fit = PsIconFit[iconKey];
+        if (fit === undefined)
+            return undefined;
+        const center = PsIconConfig.center;
+        return `translate(${center} ${center}) scale(${fit.scale}) translate(${-fit.centerX} ${-fit.centerY})`;
+    }
+    static strokeWidth(iconKey) {
+        const fit = PsIconFit[iconKey];
+        if (fit === undefined)
+            return PsIconConfig.strokeWidth;
+        return PsIconConfig.strokeWidth / fit.scale;
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { KeyboardTypeOptions } from 'react-native';
+import type { PsTextFieldType } from '../interfaces/ps-text-field-type';
+export declare class PsKeyboardService {
+    static isSecure(type: PsTextFieldType): boolean;
+    static isFree(type: PsTextFieldType): boolean;
+    static keyboardType(type: PsTextFieldType): KeyboardTypeOptions;
+}

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

@@ -0,0 +1,22 @@
+export class PsKeyboardService {
+    static isSecure(type) {
+        return type === 'password';
+    }
+    static isFree(type) {
+        return type === 'text';
+    }
+    static keyboardType(type) {
+        switch (type) {
+            case 'email':
+                return 'email-address';
+            case 'number':
+                return 'numeric';
+            case 'tel':
+                return 'phone-pad';
+            case 'url':
+                return 'url';
+            default:
+                return 'default';
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type ReactElement, type ReactNode } from 'react';
+import type { PsMenuItem } from '../interfaces/ps-menu-item';
+export type PsListVariant = 'grouped' | 'plain';
+export declare class PsListService {
+    static hasGutter(variant: PsListVariant): boolean;
+    static interleave(children: ReactNode, createDivider: (key: string) => ReactElement): ReactNode[];
+    static swipes(leading?: PsMenuItem, trailing?: PsMenuItem): PsMenuItem[];
+    static menuItems(actions?: PsMenuItem[], swipeActions?: PsMenuItem[]): PsMenuItem[];
+}

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

@@ -0,0 +1,18 @@
+import { Children } from 'react';
+export class PsListService {
+    static hasGutter(variant) {
+        return variant !== 'plain';
+    }
+    static interleave(children, createDivider) {
+        return Children.toArray(children).flatMap((child, index) => index === 0 ? [child] : [createDivider(`ps-list-divider-${index}`), child]);
+    }
+    static swipes(leading, trailing) {
+        return [leading, trailing].filter((item) => item !== undefined);
+    }
+    static menuItems(actions, swipeActions) {
+        const first = actions === undefined ? [] : actions;
+        const second = swipeActions === undefined ? [] : swipeActions;
+        const ids = new Set(first.map((item) => item.id));
+        return [...first, ...second.filter((item) => !ids.has(item.id))];
+    }
+}

package/dist/services/ps-list-skeleton-service.d.ts

@@ -0,0 +1,6 @@
+import type { PsListSkeletonLayout, PsListSkeletonResolved, PsSkeletonRowLayout } from '../components/ps-list/ps-list-props';
+export declare class PsListSkeletonService {
+    static resolve(layout: PsListSkeletonLayout | undefined): PsListSkeletonResolved;
+    static rows(shape: PsListSkeletonResolved): PsSkeletonRowLayout[];
+    static keys(count: number, prefix: string): string[];
+}

package/dist/services/ps-list-skeleton-service.js

@@ -0,0 +1,22 @@
+import { PsListConfig } from '../constants/ps-list-config';
+export class PsListSkeletonService {
+    static resolve(layout) {
+        const given = layout === undefined ? {} : layout;
+        return {
+            hasLeadingIcon: given.hasLeadingIcon === true,
+            hasSubtitle: given.hasSubtitle !== false,
+            hasValue: given.hasValue === true,
+            rowLayout: given.rowLayout,
+            rows: given.rows === undefined ? PsListConfig.skeletonRows : given.rows,
+            sections: given.sections === undefined ? PsListConfig.skeletonSections : given.sections,
+        };
+    }
+    static rows(shape) {
+        if (shape.rowLayout !== undefined)
+            return shape.rowLayout;
+        return Array.from({ length: shape.rows }, () => ({}));
+    }
+    static keys(count, prefix) {
+        return Array.from({ length: count }, (_, index) => `${prefix}-${index}`);
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare class PsMobileColorService {
+    static withAlpha(hex: string, alpha: number): string;
+}

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

@@ -0,0 +1,9 @@
+export class PsMobileColorService {
+    static withAlpha(hex, alpha) {
+        const channel = Math.round(alpha * 255)
+            .toString(16)
+            .padStart(2, '0')
+            .toUpperCase();
+        return `${hex.slice(0, 7)}${channel}`;
+    }
+}

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

@@ -0,0 +1,7 @@
+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;
+}

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

@@ -0,0 +1,104 @@
+import { PallasoftBrandColorService, PallasoftChartColor, PallasoftColor, PallasoftDarkChartColor, PallasoftDarkColor, } 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';
+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),
+            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;
+        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,
+            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,
+        };
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { PsSelectOption } from '../components/ps-select/ps-select-props';
+import type { PsNativeMenuItem } from '../interfaces/ps-native-menu-item';
+export declare class PsNativeMenuService {
+    static items(options: PsSelectOption[], value: string): PsNativeMenuItem[];
+}

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

@@ -0,0 +1,14 @@
+import { PsNativeMenuConfig } from '../constants/ps-native-menu-config';
+export class PsNativeMenuService {
+    static items(options, value) {
+        return options.map((option) => {
+            const isSelected = option.value === value;
+            return {
+                isSelected,
+                label: option.label,
+                systemImage: isSelected ? PsNativeMenuConfig.selectedSymbol : undefined,
+                value: option.value,
+            };
+        });
+    }
+}

package/dist/services/ps-page-header-service.d.ts

@@ -0,0 +1,4 @@
+import type { PsPageHeaderLayout } from '../interfaces/ps-page-header-layout';
+export declare class PsPageHeaderService {
+    static layout(): PsPageHeaderLayout;
+}

package/dist/services/ps-page-header-service.js

@@ -0,0 +1,11 @@
+import { PsPageHeaderConfig } from '../constants/ps-page-header-config';
+import { PsTextConfig } from '../constants/ps-text-config';
+export class PsPageHeaderService {
+    static layout() {
+        const gap = PsPageHeaderConfig.buttonSize - PsTextConfig.title.lineHeight;
+        return {
+            actionOffset: Math.max(0, -gap / 2),
+            titleOffset: Math.max(0, gap / 2),
+        };
+    }
+}

package/dist/services/ps-remote-data-service.d.ts

@@ -0,0 +1,6 @@
+import type { PsRemoteDataUpdate } from '../interfaces/ps-remote-data-update';
+export declare class PsRemoteDataService {
+    static rowsOf<T>(data: T | null): T[];
+    static apply<T>(rows: T[], updates: PsRemoteDataUpdate<T>[]): T[];
+    static shown<T>(rows: T[]): T | null;
+}

package/dist/services/ps-remote-data-service.js

@@ -0,0 +1,13 @@
+export class PsRemoteDataService {
+    static rowsOf(data) {
+        return data === null ? [] : [data];
+    }
+    static apply(rows, updates) {
+        if (rows.length === 0)
+            return rows;
+        return [updates.reduce((current, update) => update(current), rows[0])];
+    }
+    static shown(rows) {
+        return rows.length === 0 ? null : rows[0];
+    }
+}

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

@@ -0,0 +1,6 @@
+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 statusBarScrim(top: number): ViewStyle;
+}

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

@@ -0,0 +1,15 @@
+import { PsLayoutConfig } from '../constants/ps-layout-config';
+export class PsScreenService {
+    static content(insets, isIos, hasGutter, gap) {
+        const gutter = hasGutter ? PsLayoutConfig.gutter : 0;
+        return {
+            gap,
+            paddingBottom: (isIos ? 0 : insets.bottom) + gutter,
+            paddingHorizontal: gutter,
+            paddingTop: (isIos ? 0 : insets.top) + gutter,
+        };
+    }
+    static statusBarScrim(top) {
+        return { height: top, left: 0, position: 'absolute', right: 0, top: 0 };
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare class PsSegmentedControlService {
+    static thumbWidth(trackWidth: number, count: number): number;
+    static thumbOffset(trackWidth: number, count: number, index: number): number;
+}

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

@@ -0,0 +1,11 @@
+import { PsSegmentedControlConfig } from '../constants/ps-segmented-control-config';
+export class PsSegmentedControlService {
+    static thumbWidth(trackWidth, count) {
+        if (count === 0)
+            return 0;
+        return (trackWidth - PsSegmentedControlConfig.padding * 2) / count;
+    }
+    static thumbOffset(trackWidth, count, index) {
+        return PsSegmentedControlService.thumbWidth(trackWidth, count) * Math.max(index, 0);
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { PsSelectOption } from '../components/ps-select/ps-select-props';
+export declare class PsSelectService {
+    static selectedLabel(options: PsSelectOption[], value: string): string;
+}

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

@@ -0,0 +1,6 @@
+export class PsSelectService {
+    static selectedLabel(options, value) {
+        const selected = options.find((option) => option.value === value);
+        return selected === undefined ? '' : selected.label;
+    }
+}

package/dist/services/ps-select-style-service.d.ts

@@ -0,0 +1,6 @@
+import type { ViewStyle } from 'react-native';
+import type { PsControlState } from '../interfaces/ps-control-state';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsSelectStyleService {
+    static pill(theme: PsMobileTheme, state: PsControlState): ViewStyle;
+}

package/dist/services/ps-select-style-service.js

@@ -0,0 +1,12 @@
+import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
+import { PsControlStyleService } from './ps-control-style-service';
+export class PsSelectStyleService {
+    static pill(theme, state) {
+        return {
+            ...PsControlStyleService.container(theme, state),
+            borderRadius: PsMobileControlConfig.pillRadius,
+            minHeight: PsMobileControlConfig.controlHeights.compact,
+            paddingHorizontal: PsMobileControlConfig.controlPaddingX.compact,
+        };
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { PsSheetAction } from '../interfaces/ps-sheet-action';
+export declare class PsSheetService {
+    static maxHeight(windowHeight: number): number;
+    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 shouldClose(isPresented: boolean, isOpen: boolean, isDismissBlocked: boolean): boolean;
+}

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

@@ -0,0 +1,28 @@
+import { PsLayoutConfig } from '../constants/ps-layout-config';
+import { PsSheetConfig } from '../constants/ps-sheet-config';
+export class PsSheetService {
+    static maxHeight(windowHeight) {
+        return Math.floor(windowHeight * PsSheetConfig.maxHeightFraction);
+    }
+    static bottomPadding(isFloating, bottomInset) {
+        return PsLayoutConfig.sheetGutter + (isFloating ? 0 : bottomInset);
+    }
+    static fittedHeight(headerHeight, bodyHeight, windowHeight) {
+        return Math.min(Math.ceil(headerHeight + bodyHeight), PsSheetService.maxHeight(windowHeight));
+    }
+    static closeAction(label, onPress) {
+        return label === undefined ? undefined : { label, onPress };
+    }
+    static isActionInactive(action) {
+        return action.isDisabled === true || action.isSubmitting === true;
+    }
+    static actionOpacity(action, isPressed) {
+        if (action.isDisabled === true) {
+            return PsSheetConfig.pressedOpacity;
+        }
+        return isPressed ? PsSheetConfig.pressedOpacity : 1;
+    }
+    static shouldClose(isPresented, isOpen, isDismissBlocked) {
+        return !isPresented && isOpen && !isDismissBlocked;
+    }
+}

package/dist/services/ps-sign-in-surface-service.d.ts

@@ -0,0 +1,7 @@
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+import type { PsSignInSurface } from '../interfaces/ps-sign-in-surface';
+export declare class PsSignInSurfaceService {
+    static readonly darkFillAlpha = 0.1;
+    static readonly darkBorderAlpha = 0.15;
+    static resolve(theme: PsMobileTheme, size: 'default' | 'large'): PsSignInSurface;
+}