@pallasoft/ps-mobile-components 1.2.0 → 1.3.0

package/dist/services/ps-app-lock-service.d.ts

@@ -0,0 +1,10 @@
+import { PsBiometryKind } from '../constants/ps-biometry-kind';
+export declare class PsAppLockService {
+    private static busyCount;
+    static isAvailable(): Promise<boolean>;
+    static biometryKind(): Promise<PsBiometryKind>;
+    static kindOf(types: number[], level: number, platform: string): PsBiometryKind;
+    static authenticate(prompt: string, cancelLabel: string): Promise<boolean>;
+    static isBusy(): boolean;
+    private static load;
+}

package/dist/services/ps-app-lock-service.js

@@ -0,0 +1,84 @@
+import { requireOptionalNativeModule } from 'expo';
+import { Platform } from 'react-native';
+import { PsAppLockConfig } from '../constants/ps-app-lock-config';
+import { PsAuthenticationTypeCode, PsSecurityLevelCode, } from '../constants/ps-app-lock-native-codes';
+import { PsBiometryKind } from '../constants/ps-biometry-kind';
+export class PsAppLockService {
+    static async isAvailable() {
+        const native = PsAppLockService.load();
+        if (native === null)
+            return false;
+        try {
+            return (await native.getEnrolledLevelAsync()) > PsSecurityLevelCode.none;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async biometryKind() {
+        const native = PsAppLockService.load();
+        if (native === null)
+            return PsBiometryKind.passcode;
+        try {
+            const [types, level] = await Promise.all([
+                native.supportedAuthenticationTypesAsync(),
+                native.getEnrolledLevelAsync(),
+            ]);
+            return PsAppLockService.kindOf(types, level, Platform.OS);
+        }
+        catch {
+            return PsBiometryKind.passcode;
+        }
+    }
+    static kindOf(types, level, platform) {
+        if (level < PsSecurityLevelCode.biometricWeak)
+            return PsBiometryKind.passcode;
+        const has = (code) => types.includes(code);
+        const face = has(PsAuthenticationTypeCode.face);
+        const fingerprint = has(PsAuthenticationTypeCode.fingerprint);
+        if (platform === PsAppLockConfig.iosPlatform && face)
+            return PsBiometryKind.face;
+        if (fingerprint)
+            return PsBiometryKind.fingerprint;
+        if (face)
+            return PsBiometryKind.face;
+        if (has(PsAuthenticationTypeCode.iris))
+            return PsBiometryKind.iris;
+        return PsBiometryKind.passcode;
+    }
+    static async authenticate(prompt, cancelLabel) {
+        const native = PsAppLockService.load();
+        if (native === null)
+            return false;
+        PsAppLockService.busyCount += 1;
+        try {
+            const result = await native.authenticateAsync({
+                cancelLabel,
+                disableDeviceFallback: false,
+                promptMessage: prompt,
+            });
+            return result.success;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            PsAppLockService.busyCount -= 1;
+        }
+    }
+    static isBusy() {
+        return PsAppLockService.busyCount > 0;
+    }
+    static load() {
+        try {
+            if (requireOptionalNativeModule(PsAppLockConfig.nativeModuleName) === null)
+                return null;
+            const loaded = require('expo-local-authentication');
+            return typeof loaded.authenticateAsync === 'function' ? loaded : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+PsAppLockService.busyCount = 0;

package/dist/services/ps-badge-tone-service.js

@@ -4,13 +4,13 @@ export class PsBadgeToneService {
     static resolve(tone, theme) {
         switch (tone) {
             case 'danger':
-                return { background: theme.dangerSoft, foreground: theme.danger };
+                return { background: theme.dangerSoft, foreground: theme.dangerText };
             case 'primary':
                 return { background: theme.primarySoft, foreground: theme.ink };
             case 'success':
-                return { background: theme.successSoft, foreground: theme.success };
+                return { background: theme.successSoft, foreground: theme.successText };
             case 'warning':
-                return { background: theme.warningSoft, foreground: theme.warning };
+                return { background: theme.warningSoft, foreground: theme.warningText };
             default:
                 return {
                     background: PsMobileColorService.withAlpha(theme.ink, PsMobileControlConfig.neutralAlpha),

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

@@ -9,8 +9,8 @@ export class PsButtonStyleService {
                     background: theme.primary,
                     border: theme.primary,
                     foreground: theme.primaryContrast,
-                    pressedBackground: theme.primary,
-                    pressedBorder: theme.primary,
+                    pressedBackground: theme.primaryPressed,
+                    pressedBorder: theme.primaryPressed,
                 };
             case 'danger':
                 return {

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

@@ -3,4 +3,5 @@ import type { PsMenuItem } from '../interfaces/ps-menu-item';
 import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
 export declare class PsContextMenuService {
     static actions(items: PsMenuItem[], theme: PsMobileTheme, hasSymbols: boolean): MenuAction[];
+    static find(items: PsMenuItem[], id: string): PsMenuItem | undefined;
 }

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

@@ -4,6 +4,9 @@ export class PsContextMenuService {
         const consistent = PsActionMenuService.consistent([{ id: 'items', items }]);
         const entries = consistent.length === 0 ? [] : consistent[0].items;
         return entries.map((item) => ({
+            subactions: item.children === undefined || item.children.length === 0
+                ? undefined
+                : PsContextMenuService.actions(item.children, theme, hasSymbols),
             attributes: {
                 destructive: item.isDanger === true,
                 disabled: item.isDisabled === true,
@@ -14,4 +17,14 @@ export class PsContextMenuService {
             title: item.label,
         }));
     }
+    static find(items, id) {
+        for (const item of items) {
+            if (item.id === id)
+                return item;
+            const nested = item.children === undefined ? undefined : PsContextMenuService.find(item.children, id);
+            if (nested !== undefined)
+                return nested;
+        }
+        return undefined;
+    }
 }

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

@@ -0,0 +1,4 @@
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsListRowStyleService {
+    static background(isSelected: boolean, isPressed: boolean, theme: PsMobileTheme): string;
+}

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

@@ -0,0 +1,11 @@
+import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
+import { PsMobileColorService } from './ps-mobile-color-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;
+    }
+}

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

@@ -2,6 +2,4 @@ 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

@@ -1,104 +1,74 @@
-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';
 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),
+        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 ? tokens.chart : 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-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-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,4 +1,6 @@
+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 bottomPadding(isFloating: boolean, bottomInset: number): number;
@@ -6,5 +8,8 @@ export declare class PsSheetService {
     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;
 }

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

@@ -22,6 +22,17 @@ export class PsSheetService {
         }
         return isPressed ? PsSheetConfig.pressedOpacity : 1;
     }
+    static trailing(action, closeLabel, onClose) {
+        if (action === null)
+            return undefined;
+        return action === undefined ? PsSheetService.closeAction(closeLabel, onClose) : action;
+    }
+    static leadingIconStyle(kind) {
+        return kind === 'back' ? { transform: [{ scaleX: -1 }] } : {};
+    }
+    static grownHeight(previous, measured, isOpen) {
+        return isOpen ? Math.max(previous, measured) : measured;
+    }
     static shouldClose(isPresented, isOpen, isDismissBlocked) {
         return !isPresented && isOpen && !isDismissBlocked;
     }

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

@@ -3,15 +3,15 @@ export class PsTextService {
     static color(tone, theme) {
         switch (tone) {
             case 'danger':
-                return theme.danger;
+                return theme.dangerText;
             case 'muted':
                 return theme.muted;
             case 'primary':
-                return theme.primary;
+                return theme.primaryText;
             case 'success':
-                return theme.success;
+                return theme.successText;
             case 'warning':
-                return theme.warning;
+                return theme.warningText;
             case 'white':
                 return theme.white;
             default: