@pallasoft/ps-mobile-components 1.2.0 → 1.4.0

package/dist/services/ps-capture-picker-service.d.ts

@@ -0,0 +1,11 @@
+import { PsCaptureSource } from '../constants/ps-capture-source';
+import type { PsCaptureOptions } from '../interfaces/ps-capture-options';
+import type { PsDeviceFile } from '../interfaces/ps-device-file';
+export declare class PsCapturePickerService {
+    static pick(source: PsCaptureSource, options?: PsCaptureOptions): Promise<PsDeviceFile[]>;
+    private static scan;
+    private static pickImage;
+    private static pickDocument;
+    private static loadImagePicker;
+    private static loadDocumentPicker;
+}

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

@@ -0,0 +1,67 @@
+import { PsCaptureConfig } from '../constants/ps-capture-config';
+import { PsCaptureSource } from '../constants/ps-capture-source';
+import { PsDeviceFileService } from './ps-device-file-service';
+import { PsDocumentScannerService } from './ps-document-scanner-service';
+export class PsCapturePickerService {
+    static async pick(source, options = {}) {
+        if (source === PsCaptureSource.Scan)
+            return PsCapturePickerService.scan(options);
+        const file = source === PsCaptureSource.Files
+            ? await PsCapturePickerService.pickDocument(options)
+            : await PsCapturePickerService.pickImage(source === PsCaptureSource.Camera, options);
+        return file === null ? [] : [file];
+    }
+    static async scan(options) {
+        if (!PsDocumentScannerService.isAvailable()) {
+            const file = await PsCapturePickerService.pickImage(true, options);
+            return file === null ? [] : [file];
+        }
+        return PsDocumentScannerService.scan({
+            fileName: options.scanFileName === undefined ? PsCaptureConfig.scanFileName : options.scanFileName,
+            jpegQuality: options.scanQuality === undefined ? PsCaptureConfig.scanQuality : options.scanQuality,
+        });
+    }
+    static async pickImage(isCamera, options) {
+        const picker = PsCapturePickerService.loadImagePicker();
+        if (picker === null)
+            return null;
+        if (isCamera && !(await picker.requestCameraPermissionsAsync()).granted)
+            return null;
+        const pickerOptions = {
+            mediaTypes: ['images'],
+            quality: options.imageQuality === undefined ? PsCaptureConfig.imageQuality : options.imageQuality,
+        };
+        const result = isCamera
+            ? await picker.launchCameraAsync(pickerOptions)
+            : await picker.launchImageLibraryAsync(pickerOptions);
+        return result.canceled ? null : PsDeviceFileService.fromImage(result.assets[0]);
+    }
+    static async pickDocument(options) {
+        const picker = PsCapturePickerService.loadDocumentPicker();
+        if (picker === null)
+            return null;
+        const result = await picker.getDocumentAsync({
+            copyToCacheDirectory: true,
+            type: options.documentTypes === undefined
+                ? [...PsCaptureConfig.documentTypes]
+                : options.documentTypes,
+        });
+        return result.canceled ? null : PsDeviceFileService.fromDocument(result.assets[0]);
+    }
+    static loadImagePicker() {
+        try {
+            return require('expo-image-picker');
+        }
+        catch {
+            return null;
+        }
+    }
+    static loadDocumentPicker() {
+        try {
+            return require('expo-document-picker');
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/services/ps-capture-source-service.d.ts

@@ -0,0 +1,10 @@
+import { PsCaptureSource } from '../constants/ps-capture-source';
+import type { PsCaptureLabels } from '../interfaces/ps-capture-labels';
+import type { PsCaptureMenuOptions } from '../interfaces/ps-capture-menu-options';
+import type { PsMenuItem } from '../interfaces/ps-menu-item';
+export declare class PsCaptureSourceService {
+    static hasCamera(): boolean;
+    static sources(hasCamera: boolean): PsCaptureSource[];
+    static items(labels: PsCaptureLabels, options: PsCaptureMenuOptions): PsMenuItem[];
+    private static loadDevice;
+}

package/dist/services/ps-capture-source-service.js

@@ -0,0 +1,31 @@
+import { PsCaptureConfig } from '../constants/ps-capture-config';
+import { PsCaptureSource } from '../constants/ps-capture-source';
+export class PsCaptureSourceService {
+    static hasCamera() {
+        const device = PsCaptureSourceService.loadDevice();
+        return device === null ? true : device.isDevice;
+    }
+    static sources(hasCamera) {
+        return hasCamera
+            ? [...PsCaptureConfig.order]
+            : PsCaptureConfig.order.filter((source) => source !== PsCaptureSource.Scan && source !== PsCaptureSource.Camera);
+    }
+    static items(labels, options) {
+        const hasCamera = options.hasCamera === undefined ? PsCaptureSourceService.hasCamera() : options.hasCamera;
+        return PsCaptureSourceService.sources(hasCamera).map((source) => ({
+            iconKey: PsCaptureConfig.icons[source],
+            id: source,
+            isDisabled: options.isDisabled,
+            label: labels[source],
+            onSelect: () => options.onPick(source),
+        }));
+    }
+    static loadDevice() {
+        try {
+            return require('expo-device');
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare class PsChartBrandService {
+    static series(bases: string[]): string[];
+    static mix(hex: string, isWhite: boolean, amount: number): string;
+}

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

@@ -0,0 +1,20 @@
+import { PsChartBrandConfig } from '../constants/ps-chart-brand-config';
+export class PsChartBrandService {
+    static series(bases) {
+        return PsChartBrandConfig.steps.map((_, index) => {
+            const step = PsChartBrandConfig.steps[Math.floor(index / bases.length)];
+            return PsChartBrandService.mix(bases[index % bases.length], step.isWhite, step.amount);
+        });
+    }
+    static mix(hex, isWhite, amount) {
+        const match = /^#([0-9a-f]{6})/i.exec(hex);
+        if (match === null)
+            return hex;
+        const target = isWhite ? 255 : 0;
+        const channels = [0, 2, 4].map((offset) => {
+            const channel = parseInt(match[1].slice(offset, offset + 2), 16);
+            return Math.round(channel + (target - channel) * amount);
+        });
+        return `#${channels.map((channel) => channel.toString(16).padStart(2, '0')).join('')}`.toUpperCase();
+    }
+}

package/dist/services/ps-chart-shape-service.d.ts

@@ -0,0 +1,7 @@
+import type { PsCartesianChartKind } from '../constants/ps-chart-kind';
+import type { PsCartesianChartSeries } from '../interfaces/ps-cartesian-chart-series';
+export declare class PsChartShapeService {
+    static barIndexes(kind: PsCartesianChartKind, series: PsCartesianChartSeries[]): number[];
+    static lineIndexes(kind: PsCartesianChartKind, series: PsCartesianChartSeries[]): number[];
+    private static indexes;
+}

package/dist/services/ps-chart-shape-service.js

@@ -0,0 +1,17 @@
+import { PsCartesianSeriesShape } from '../constants/ps-cartesian-series-shape';
+import { PsChartKindService } from './ps-chart-kind-service';
+export class PsChartShapeService {
+    static barIndexes(kind, series) {
+        if (!PsChartKindService.isBars(kind))
+            return [];
+        return PsChartShapeService.indexes(series, (entry) => entry.shape !== PsCartesianSeriesShape.Line);
+    }
+    static lineIndexes(kind, series) {
+        if (!PsChartKindService.isBars(kind))
+            return series.map((_, index) => index);
+        return PsChartShapeService.indexes(series, (entry) => entry.shape === PsCartesianSeriesShape.Line);
+    }
+    static indexes(series, matches) {
+        return series.flatMap((entry, index) => (matches(entry) ? [index] : []));
+    }
+}

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-control-style-service.js

@@ -1,4 +1,5 @@
 import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
+import { PsStateService } from './ps-state-service';
 export class PsControlStyleService {
     static container(theme, state) {
         return {
@@ -9,8 +10,8 @@ export class PsControlStyleService {
             borderWidth: 1,
             flexDirection: 'row',
             minHeight: PsMobileControlConfig.controlHeights.default,
-            opacity: state.isDisabled ? PsMobileControlConfig.disabledOpacity : 1,
-            outlineColor: state.isFocused ? theme.primary : undefined,
+            opacity: state.isDisabled ? PsStateService.disabledOpacity() : 1,
+            outlineColor: state.isFocused ? PsStateService.ringColor(theme, state.hasError) : undefined,
             outlineOffset: state.isFocused ? PsMobileControlConfig.ringOffset : undefined,
             outlineStyle: state.isFocused ? 'solid' : undefined,
             outlineWidth: state.isFocused ? PsMobileControlConfig.ringWidth : undefined,

package/dist/services/ps-date-picker-service.d.ts

@@ -1,5 +1,8 @@
+import type { PsDateDialogColors } from '../interfaces/ps-date-dialog-colors';
 import type { PsDateLimits } from '../interfaces/ps-date-limits';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
 export declare class PsDatePickerService {
     static limits(min: string | undefined, max: string | undefined): PsDateLimits;
     static clamp(value: string, min: string | undefined, max: string | undefined): string;
+    static dialogColors(theme: PsMobileTheme): PsDateDialogColors;
 }

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

@@ -13,4 +13,25 @@ export class PsDatePickerService {
             return max;
         return value;
     }
+    static dialogColors(theme) {
+        return {
+            containerColor: theme.surface,
+            currentYearContentColor: theme.primaryText,
+            dayContentColor: theme.ink,
+            disabledDayContentColor: theme.muted,
+            dividerColor: theme.line,
+            headlineContentColor: theme.ink,
+            navigationContentColor: theme.ink,
+            selectedDayContainerColor: theme.primary,
+            selectedDayContentColor: theme.primaryContrast,
+            selectedYearContainerColor: theme.primary,
+            selectedYearContentColor: theme.primaryContrast,
+            subheadContentColor: theme.muted,
+            titleContentColor: theme.muted,
+            todayContentColor: theme.primaryText,
+            todayDateBorderColor: theme.primaryText,
+            weekdayContentColor: theme.muted,
+            yearContentColor: theme.ink,
+        };
+    }
 }

package/dist/services/ps-device-file-service.d.ts

@@ -0,0 +1,14 @@
+import type { PsDeviceFile } from '../interfaces/ps-device-file';
+export declare class PsDeviceFileService {
+    static fromImage(asset: {
+        fileName?: string | null;
+        mimeType?: string;
+        uri: string;
+    }): PsDeviceFile;
+    static fromDocument(asset: {
+        mimeType?: string;
+        name: string;
+        uri: string;
+    }): PsDeviceFile;
+    static nameOf(uri: string): string;
+}

package/dist/services/ps-device-file-service.js

@@ -0,0 +1,27 @@
+import { PsCaptureConfig } from '../constants/ps-capture-config';
+export class PsDeviceFileService {
+    static fromImage(asset) {
+        return {
+            name: asset.fileName === undefined || asset.fileName === null || asset.fileName === ''
+                ? PsDeviceFileService.nameOf(asset.uri)
+                : asset.fileName,
+            type: asset.mimeType === undefined || asset.mimeType === ''
+                ? PsCaptureConfig.imageFallbackType
+                : asset.mimeType,
+            uri: asset.uri,
+        };
+    }
+    static fromDocument(asset) {
+        return {
+            name: asset.name === '' ? PsDeviceFileService.nameOf(asset.uri) : asset.name,
+            type: asset.mimeType === undefined || asset.mimeType === ''
+                ? PsCaptureConfig.unknownType
+                : asset.mimeType,
+            uri: asset.uri,
+        };
+    }
+    static nameOf(uri) {
+        const name = uri.split('/').pop();
+        return name === undefined || name === '' ? uri : name;
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { PsDocumentSource } from '../interfaces/ps-document-source';
+export declare class PsDocumentFileService {
+    static isAvailable(): boolean;
+    static local(source: PsDocumentSource, name: string, fallbackExtension: string): Promise<string | null>;
+    static readText(uri: string): Promise<string | null>;
+    static preview(uri: string, name: string): Promise<boolean>;
+    static cacheName(uri: string, name: string, fallbackExtension: string): string;
+    private static hash;
+    private static load;
+}

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

@@ -0,0 +1,75 @@
+import { PsDocumentFileConfig } from '../constants/ps-document-file-config';
+export class PsDocumentFileService {
+    static isAvailable() {
+        return PsDocumentFileService.load() !== null;
+    }
+    static async local(source, name, fallbackExtension) {
+        const system = PsDocumentFileService.load();
+        if (system === null)
+            return null;
+        try {
+            const directory = new system.Directory(system.Paths.cache, PsDocumentFileConfig.cacheFolder);
+            if (!directory.exists)
+                directory.create({ intermediates: true });
+            const file = new system.File(directory, PsDocumentFileService.cacheName(source.uri, name, fallbackExtension));
+            if (file.exists)
+                return file.uri;
+            const saved = await system.File.downloadFileAsync(source.uri, file, {
+                headers: source.headers,
+                idempotent: true,
+            });
+            return saved.uri;
+        }
+        catch {
+            return null;
+        }
+    }
+    static async readText(uri) {
+        const system = PsDocumentFileService.load();
+        if (system === null)
+            return null;
+        try {
+            return await new system.File(uri).text();
+        }
+        catch {
+            return null;
+        }
+    }
+    static async preview(uri, name) {
+        const system = PsDocumentFileService.load();
+        if (system === null)
+            return false;
+        try {
+            await system.File.preview(new system.File(uri), { title: name });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static cacheName(uri, name, fallbackExtension) {
+        const dot = name.lastIndexOf('.');
+        const hasExtension = dot > 0 && dot < name.length - 1;
+        const base = hasExtension ? name.slice(0, dot) : name.replace(/\.$/, '');
+        const extension = hasExtension ? name.slice(dot + 1).toLowerCase() : fallbackExtension;
+        const safeBase = base.replace(PsDocumentFileConfig.unsafeName, '-');
+        return `${PsDocumentFileService.hash(uri)}-${safeBase}.${extension}`;
+    }
+    static hash(value) {
+        let hash = PsDocumentFileConfig.hashSeed;
+        for (let index = 0; index < value.length; index += 1)
+            hash =
+                (hash * PsDocumentFileConfig.hashMultiplier + value.charCodeAt(index)) %
+                    PsDocumentFileConfig.hashModulus;
+        return hash.toString(PsDocumentFileConfig.hashRadix);
+    }
+    static load() {
+        try {
+            const loaded = require('expo-file-system');
+            return typeof loaded.File === 'function' ? loaded : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { PsDocumentItem } from '../interfaces/ps-document-item';
+export declare class PsDocumentOpenService {
+    static canOpen(item: PsDocumentItem): boolean;
+    static open(item: PsDocumentItem): Promise<boolean>;
+}

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

@@ -0,0 +1,16 @@
+import { PsDocumentFileConfig } from '../constants/ps-document-file-config';
+import { PsDocumentKind } from '../constants/ps-document-kind';
+import { PsDocumentFileService } from './ps-document-file-service';
+export class PsDocumentOpenService {
+    static canOpen(item) {
+        return item.source !== null;
+    }
+    static async open(item) {
+        if (item.source === null)
+            return false;
+        const uri = await PsDocumentFileService.local(item.source, item.name, item.kind === PsDocumentKind.Pdf
+            ? PsDocumentFileConfig.pdfExtension
+            : PsDocumentFileConfig.fallbackExtension);
+        return uri === null ? false : PsDocumentFileService.preview(uri, item.name);
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { PsDocumentPdfState } from '../interfaces/ps-document-pdf-state';
+import type { PsDocumentSource } from '../interfaces/ps-document-source';
+export declare class PsDocumentPdfService {
+    private static readonly rendered;
+    static isAvailable(): boolean;
+    static cover(source: PsDocumentSource, name: string): Promise<PsDocumentPdfState>;
+    static pages(source: PsDocumentSource, name: string): Promise<PsDocumentPdfState>;
+    static clear(): void;
+    private static render;
+}

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.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,8 @@
+import { PsStateService } from './ps-state-service';
+export class PsListRowStyleService {
+    static background(isSelected, isPressed, theme) {
+        if (isSelected)
+            return isPressed ? theme.primarySoftStrong : theme.primarySoft;
+        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);
+    }
+}