@pallasoft/ps-mobile-components 1.5.0 → 1.7.0

package/dist/index.d.ts

@@ -49,6 +49,8 @@ export * from './constants/ps-capture-source';
 export * from './constants/ps-document-kind';
 export * from './constants/ps-document-load-status';
 export * from './constants/ps-document-scanner-config';
+export * from './constants/ps-scan-format';
+export * from './interfaces/ps-scan-format-labels';
 export * from './constants/ps-chart-delta';
 export * from './constants/ps-cartesian-series-shape';
 export * from './constants/ps-chart-kind';
@@ -174,3 +176,9 @@ export * from './interfaces/ps-barcode-scan';
 export * from './interfaces/ps-barcode-scanner-labels';
 export * from './interfaces/use-ps-barcode-scanner-result';
 export { PsBarcodeScannerService } from './services/ps-barcode-scanner-service';
+export * from './components/ps-infinite-list';
+export * from './hooks/use-ps-infinite-data';
+export * from './interfaces/ps-infinite-data-options';
+export * from './interfaces/ps-infinite-data-result';
+export * from './interfaces/ps-infinite-data-update';
+export * from './interfaces/ps-infinite-page';

package/dist/index.js

@@ -49,6 +49,8 @@ export * from './constants/ps-capture-source';
 export * from './constants/ps-document-kind';
 export * from './constants/ps-document-load-status';
 export * from './constants/ps-document-scanner-config';
+export * from './constants/ps-scan-format';
+export * from './interfaces/ps-scan-format-labels';
 export * from './constants/ps-chart-delta';
 export * from './constants/ps-cartesian-series-shape';
 export * from './constants/ps-chart-kind';
@@ -169,3 +171,9 @@ export * from './interfaces/ps-barcode-scan';
 export * from './interfaces/ps-barcode-scanner-labels';
 export * from './interfaces/use-ps-barcode-scanner-result';
 export { PsBarcodeScannerService } from './services/ps-barcode-scanner-service';
+export * from './components/ps-infinite-list';
+export * from './hooks/use-ps-infinite-data';
+export * from './interfaces/ps-infinite-data-options';
+export * from './interfaces/ps-infinite-data-result';
+export * from './interfaces/ps-infinite-data-update';
+export * from './interfaces/ps-infinite-page';

package/dist/interfaces/ps-capture-options.d.ts

@@ -1,6 +1,8 @@
+import type { PsScanFormatLabels } from './ps-scan-format-labels';
 export interface PsCaptureOptions {
     documentTypes?: string[];
     imageQuality?: number;
     scanFileName?: string;
+    scanFormatLabels?: PsScanFormatLabels;
     scanQuality?: number;
 }

package/dist/interfaces/ps-document-scanner-options.d.ts

@@ -1,5 +1,7 @@
+import type { PsScanFormatLabels } from './ps-scan-format-labels';
 export interface PsDocumentScannerOptions {
     fileName?: string;
+    formatLabels?: PsScanFormatLabels;
     jpegQuality?: number;
     maxPages?: number;
 }

package/dist/interfaces/ps-image-manipulator-native.d.ts

@@ -0,0 +1,19 @@
+export interface PsImageManipulatorResult {
+    uri: string;
+}
+export interface PsImageManipulatorContext {
+    renderAsync: () => Promise<PsImageManipulatorRendered>;
+}
+export interface PsImageManipulatorRendered {
+    saveAsync: (options: {
+        format: string;
+    }) => Promise<PsImageManipulatorResult>;
+}
+export interface PsImageManipulatorModule {
+    ImageManipulator: {
+        manipulate: (uri: string) => PsImageManipulatorContext;
+    };
+    SaveFormat: {
+        PNG: string;
+    };
+}

package/dist/interfaces/ps-image-manipulator-native.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-infinite-data-options.d.ts

@@ -0,0 +1,10 @@
+import type { PsInfinitePage } from './ps-infinite-page';
+export interface PsInfiniteDataOptions<T> {
+    getKey: (item: T) => string;
+    isEnabled?: boolean;
+    key: string;
+    loadPage: (cursor: string | null) => Promise<PsInfinitePage<T>>;
+    onSettled?: () => Promise<unknown>;
+    onWriteFailed?: () => void;
+    refreshKey?: number | string;
+}

package/dist/interfaces/ps-infinite-data-options.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-infinite-data-result.d.ts

@@ -0,0 +1,12 @@
+import type { PsInfiniteDataUpdate } from './ps-infinite-data-update';
+export interface PsInfiniteDataResult<T> {
+    committedItems: T[];
+    error: boolean;
+    hasMore: boolean;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    items: T[];
+    loadMore: () => Promise<void>;
+    refresh: () => Promise<void>;
+    write: (update: PsInfiniteDataUpdate<T>, request: () => Promise<unknown>) => Promise<boolean>;
+}

package/dist/interfaces/ps-infinite-data-result.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-infinite-data-state.d.ts

@@ -0,0 +1,8 @@
+export interface PsInfiniteDataState<T> {
+    error: boolean;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    items: T[];
+    nextCursor: string | null;
+    pages: number;
+}

package/dist/interfaces/ps-infinite-data-state.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-infinite-data-update.d.ts

@@ -0,0 +1 @@
+export type PsInfiniteDataUpdate<T> = (items: T[]) => T[];

package/dist/interfaces/ps-infinite-data-update.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-infinite-data-write.d.ts

@@ -0,0 +1,6 @@
+import type { PsInfiniteDataUpdate } from './ps-infinite-data-update';
+export interface PsInfiniteDataWrite<T> {
+    request: () => Promise<unknown>;
+    resolve: (isSaved: boolean) => void;
+    update: PsInfiniteDataUpdate<T>;
+}

package/dist/interfaces/ps-infinite-data-write.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-infinite-page.d.ts

@@ -0,0 +1,4 @@
+export interface PsInfinitePage<T> {
+    items: T[];
+    nextCursor: string | null;
+}

package/dist/interfaces/ps-infinite-page.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-menu-popup-container-style.d.ts

@@ -0,0 +1,8 @@
+export interface PsMenuPopupContainerStyle {
+    backgroundColor: string;
+    borderColor: string;
+    borderRadius: number;
+    borderWidth: number;
+    elevation: number;
+    paddingVertical: number;
+}

package/dist/interfaces/ps-menu-popup-container-style.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-menu-popup-divider-style.d.ts

@@ -0,0 +1,4 @@
+export interface PsMenuPopupDividerStyle {
+    backgroundColor: string;
+    marginVertical: number;
+}

package/dist/interfaces/ps-menu-popup-divider-style.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-menu-popup-layout.d.ts

@@ -1,4 +1,5 @@
 export interface PsMenuPopupLayout {
+    isBelow: boolean;
     left: number;
     maxHeight: number;
     top: number;

package/dist/interfaces/ps-menu-popup-row-style.d.ts

@@ -0,0 +1,6 @@
+export interface PsMenuPopupRowStyle {
+    backgroundColor: string;
+    borderRadius: number;
+    marginHorizontal: number;
+    paddingHorizontal: number;
+}

package/dist/interfaces/ps-menu-popup-row-style.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-menu-popup-size.d.ts

@@ -0,0 +1,4 @@
+export interface PsMenuPopupSize {
+    height: number;
+    width: number;
+}

package/dist/interfaces/ps-menu-popup-size.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-page-size.d.ts

@@ -0,0 +1,4 @@
+export interface PsPageSize {
+    height: number;
+    width: number;
+}

package/dist/interfaces/ps-page-size.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-pdf-page.d.ts

@@ -0,0 +1,5 @@
+export interface PsPdfPage {
+    bytes: Uint8Array;
+    height: number;
+    width: number;
+}

package/dist/interfaces/ps-pdf-page.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ps-scan-format-labels.d.ts

@@ -0,0 +1,7 @@
+export interface PsScanFormatLabels {
+    cancel: string;
+    images: string;
+    message: string;
+    pdf: string;
+    title: string;
+}

package/dist/interfaces/ps-scan-format-labels.js

@@ -0,0 +1 @@
+export {};

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

@@ -23,6 +23,7 @@ export class PsCapturePickerService {
         }
         return PsDocumentScannerService.scan({
             fileName: options.scanFileName === undefined ? PsCaptureConfig.scanFileName : options.scanFileName,
+            formatLabels: options.scanFormatLabels,
             jpegQuality: options.scanQuality === undefined ? PsCaptureConfig.scanQuality : options.scanQuality,
         });
     }

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

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

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

@@ -1,4 +1,7 @@
 import { PsDocumentScannerConfig } from '../constants/ps-document-scanner-config';
+import { PsScanOutputConfig } from '../constants/ps-scan-output-config';
+import { PsScanFormatPromptService } from './ps-scan-format-prompt-service';
+import { PsScanOutputService } from './ps-scan-output-service';
 export class PsDocumentScannerService {
     static isAvailable() {
         return PsDocumentScannerService.load() !== null;
@@ -16,18 +19,32 @@ export class PsDocumentScannerService {
             return [];
         const uris = response.scannedImages === undefined ? [] : response.scannedImages;
         const limited = maxPages === null ? uris : uris.slice(0, maxPages);
-        return PsDocumentScannerService.toFiles(limited, options.fileName);
+        const files = PsDocumentScannerService.toFiles(limited, options.fileName);
+        return PsDocumentScannerService.format(files, options);
+    }
+    static async format(files, options) {
+        const labels = options.formatLabels;
+        if (labels === undefined || files.length === 0 || !PsScanOutputService.isAvailable())
+            return files;
+        await new Promise((resolve) => setTimeout(resolve, PsScanOutputConfig.promptDelayMs));
+        const format = await PsScanFormatPromptService.ask(labels, PsScanFormatPromptService.preferred(files.length));
+        return format === null
+            ? []
+            : PsScanOutputService.produce(files, format, PsDocumentScannerService.base(options.fileName));
     }
     static toFiles(uris, fileName) {
-        const base = fileName === undefined || fileName === ''
-            ? PsDocumentScannerConfig.defaultFileName
-            : fileName;
+        const base = PsDocumentScannerService.base(fileName);
         return uris.map((uri, index) => ({
             name: `${base}-${index + 1}.${PsDocumentScannerConfig.fileExtension}`,
             type: PsDocumentScannerConfig.fileType,
             uri,
         }));
     }
+    static base(fileName) {
+        return fileName === undefined || fileName === ''
+            ? PsDocumentScannerConfig.defaultFileName
+            : fileName;
+    }
     static quality(jpegQuality) {
         if (jpegQuality === undefined)
             return PsDocumentScannerConfig.defaultJpegQuality;

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

@@ -0,0 +1,8 @@
+import type { PsInfiniteDataState } from '../interfaces/ps-infinite-data-state';
+import type { PsInfiniteDataUpdate } from '../interfaces/ps-infinite-data-update';
+export declare class PsInfiniteDataService {
+    static initial<T>(): PsInfiniteDataState<T>;
+    static merge<T>(existing: T[], incoming: T[], getKey: (item: T) => string): T[];
+    static apply<T>(rows: T[], updates: PsInfiniteDataUpdate<T>[]): T[];
+    static hasMore<T>(state: PsInfiniteDataState<T>): boolean;
+}

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

@@ -0,0 +1,22 @@
+export class PsInfiniteDataService {
+    static initial() {
+        return {
+            error: false,
+            isLoading: true,
+            isLoadingMore: false,
+            items: [],
+            nextCursor: null,
+            pages: 0,
+        };
+    }
+    static merge(existing, incoming, getKey) {
+        const keys = new Set(existing.map(getKey));
+        return [...existing, ...incoming.filter((item) => !keys.has(getKey(item)))];
+    }
+    static apply(rows, updates) {
+        return updates.reduce((current, update) => update(current), rows);
+    }
+    static hasMore(state) {
+        return state.nextCursor !== null;
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { ViewStyle } from 'react-native';
+import type { PsInfiniteSection } from '../components/ps-infinite-list/ps-infinite-list-props';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsInfiniteListService {
+    static readonly itemsKey = "ps-infinite-items";
+    static sections<T>(items: T[] | undefined, sections: PsInfiniteSection<T>[] | undefined): PsInfiniteSection<T>[];
+    static shouldLoadMore(hasMore: boolean, isLoading: boolean, isLoadingMore: boolean): boolean;
+    static itemFrame(theme: PsMobileTheme, index: number, count: number): ViewStyle;
+    static divider(theme: PsMobileTheme): ViewStyle;
+}

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

@@ -0,0 +1,36 @@
+import { PsListConfig } from '../constants/ps-list-config';
+import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
+export class PsInfiniteListService {
+    static sections(items, sections) {
+        if (sections !== undefined)
+            return sections.filter((section) => section.data.length > 0);
+        return items === undefined || items.length === 0
+            ? []
+            : [{ data: items, key: PsInfiniteListService.itemsKey }];
+    }
+    static shouldLoadMore(hasMore, isLoading, isLoadingMore) {
+        return hasMore && !isLoading && !isLoadingMore;
+    }
+    static itemFrame(theme, index, count) {
+        const isFirst = index === 0;
+        const isLast = index === count - 1;
+        const radius = PsMobileControlConfig.cardRadius;
+        return {
+            backgroundColor: theme.surface,
+            borderBottomLeftRadius: isLast ? radius : 0,
+            borderBottomRightRadius: isLast ? radius : 0,
+            borderBottomWidth: isLast ? 1 : 0,
+            borderColor: theme.line,
+            borderLeftWidth: 1,
+            borderRightWidth: 1,
+            borderTopLeftRadius: isFirst ? radius : 0,
+            borderTopRightRadius: isFirst ? radius : 0,
+            borderTopWidth: isFirst ? 1 : 0,
+            overflow: 'hidden',
+        };
+    }
+    static divider(theme) {
+        return { backgroundColor: theme.line, height: 1, marginLeft: PsListConfig.dividerInset };
+    }
+}
+PsInfiniteListService.itemsKey = 'ps-infinite-items';

package/dist/services/ps-jpeg-size-service.d.ts

@@ -0,0 +1,4 @@
+import type { PsPageSize } from '../interfaces/ps-page-size';
+export declare class PsJpegSizeService {
+    static size(bytes: Uint8Array): PsPageSize | null;
+}

package/dist/services/ps-jpeg-size-service.js

@@ -0,0 +1,32 @@
+import { PsScanOutputConfig } from '../constants/ps-scan-output-config';
+export class PsJpegSizeService {
+    static size(bytes) {
+        const prefix = PsScanOutputConfig.jpegMarkerPrefix;
+        if (bytes.length < 4 || bytes[0] !== prefix || bytes[1] !== PsScanOutputConfig.jpegStartMarker)
+            return null;
+        let cursor = 2;
+        while (cursor + 4 <= bytes.length) {
+            if (bytes[cursor] !== prefix) {
+                cursor += 1;
+                continue;
+            }
+            const marker = bytes[cursor + 1];
+            if (marker === prefix) {
+                cursor += 1;
+                continue;
+            }
+            const length = (bytes[cursor + 2] << 8) | bytes[cursor + 3];
+            if (PsScanOutputConfig.jpegSizeMarkers.some((size) => size === marker)) {
+                const at = cursor + 2 + PsScanOutputConfig.jpegSizeOffset;
+                if (at + 4 > bytes.length)
+                    return null;
+                return {
+                    height: (bytes[at] << 8) | bytes[at + 1],
+                    width: (bytes[at + 2] << 8) | bytes[at + 3],
+                };
+            }
+            cursor += PsScanOutputConfig.jpegSegmentHeaderLength + length;
+        }
+        return null;
+    }
+}

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

@@ -14,6 +14,7 @@ export class PsMenuPopupService {
         const alignedRight = anchor.x + menuWidth > window.width - margin;
         const left = alignedRight ? anchor.x + anchor.width - menuWidth : anchor.x;
         return {
+            isBelow,
             left: Math.max(margin, Math.min(left, window.width - margin - menuWidth)),
             maxHeight: Math.max(room, 0),
             top,

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

@@ -0,0 +1,13 @@
+import type { PsFontWeight } from '../interfaces/ps-font-weight';
+import type { PsMaterialScheme } from '../interfaces/ps-material-scheme';
+import type { PsMenuPopupContainerStyle } from '../interfaces/ps-menu-popup-container-style';
+import type { PsMenuPopupDividerStyle } from '../interfaces/ps-menu-popup-divider-style';
+import type { PsMenuPopupRowStyle } from '../interfaces/ps-menu-popup-row-style';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsMenuPopupStyleService {
+    static isMaterial(os?: string): boolean;
+    static container(theme: PsMobileTheme, scheme: PsMaterialScheme, isMaterial: boolean): PsMenuPopupContainerStyle;
+    static row(theme: PsMobileTheme, scheme: PsMaterialScheme, isMaterial: boolean, isChecked: boolean, isPressed: boolean): PsMenuPopupRowStyle;
+    static divider(theme: PsMobileTheme, scheme: PsMaterialScheme, isMaterial: boolean): PsMenuPopupDividerStyle;
+    static labelWeight(isMaterial: boolean, isChecked: boolean): PsFontWeight;
+}

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

@@ -0,0 +1,55 @@
+import { Platform } from 'react-native';
+import { PsMaterialMenuConfig } from '../constants/ps-material-menu-config';
+import { PsMenuPopupConfig } from '../constants/ps-menu-popup-config';
+export class PsMenuPopupStyleService {
+    static isMaterial(os = Platform.OS) {
+        return os === 'android';
+    }
+    static container(theme, scheme, isMaterial) {
+        if (isMaterial)
+            return {
+                backgroundColor: scheme.surfaceContainer,
+                borderColor: scheme.surfaceContainer,
+                borderRadius: PsMaterialMenuConfig.radius,
+                borderWidth: 0,
+                elevation: PsMaterialMenuConfig.elevation,
+                paddingVertical: PsMaterialMenuConfig.paddingVertical,
+            };
+        return {
+            backgroundColor: theme.surface,
+            borderColor: theme.line,
+            borderRadius: PsMenuPopupConfig.radius,
+            borderWidth: 1,
+            elevation: 0,
+            paddingVertical: PsMenuPopupConfig.paddingVertical,
+        };
+    }
+    static row(theme, scheme, isMaterial, isChecked, isPressed) {
+        if (isMaterial)
+            return {
+                backgroundColor: isChecked ? scheme.secondaryContainer : 'transparent',
+                borderRadius: PsMaterialMenuConfig.itemRadius,
+                marginHorizontal: PsMaterialMenuConfig.itemInset,
+                paddingHorizontal: PsMaterialMenuConfig.rowPaddingHorizontal,
+            };
+        return {
+            backgroundColor: isPressed ? theme.primarySoft : 'transparent',
+            borderRadius: 0,
+            marginHorizontal: 0,
+            paddingHorizontal: PsMenuPopupConfig.rowPaddingHorizontal,
+        };
+    }
+    static divider(theme, scheme, isMaterial) {
+        if (isMaterial)
+            return {
+                backgroundColor: scheme.outlineVariant,
+                marginVertical: PsMaterialMenuConfig.dividerInset,
+            };
+        return { backgroundColor: theme.line, marginVertical: 0 };
+    }
+    static labelWeight(isMaterial, isChecked) {
+        if (isMaterial)
+            return 'medium';
+        return isChecked ? 'semibold' : 'regular';
+    }
+}

package/dist/services/ps-scan-format-prompt-service.d.ts

@@ -0,0 +1,6 @@
+import { PsScanFormat } from '../constants/ps-scan-format';
+import type { PsScanFormatLabels } from '../interfaces/ps-scan-format-labels';
+export declare class PsScanFormatPromptService {
+    static ask(labels: PsScanFormatLabels, preferred: PsScanFormat): Promise<PsScanFormat | null>;
+    static preferred(pageCount: number): PsScanFormat;
+}

package/dist/services/ps-scan-format-prompt-service.js

@@ -0,0 +1,21 @@
+import { Alert } from 'react-native';
+import { PsScanFormat } from '../constants/ps-scan-format';
+export class PsScanFormatPromptService {
+    static ask(labels, preferred) {
+        return new Promise((resolve) => {
+            const choice = (format, text) => ({
+                isPreferred: format === preferred,
+                onPress: () => resolve(format),
+                text,
+            });
+            Alert.alert(labels.title, labels.message, [
+                choice(PsScanFormat.Pdf, labels.pdf),
+                choice(PsScanFormat.Png, labels.images),
+                { onPress: () => resolve(null), style: 'cancel', text: labels.cancel },
+            ], { cancelable: true, onDismiss: () => resolve(null) });
+        });
+    }
+    static preferred(pageCount) {
+        return pageCount > 1 ? PsScanFormat.Pdf : PsScanFormat.Png;
+    }
+}

package/dist/services/ps-scan-image-converter-service.d.ts

@@ -0,0 +1,5 @@
+export declare class PsScanImageConverterService {
+    static isAvailable(): boolean;
+    static toPng(uri: string): Promise<string>;
+    private static load;
+}

package/dist/services/ps-scan-image-converter-service.js

@@ -0,0 +1,22 @@
+export class PsScanImageConverterService {
+    static isAvailable() {
+        return PsScanImageConverterService.load() !== null;
+    }
+    static async toPng(uri) {
+        const loaded = PsScanImageConverterService.load();
+        if (loaded === null)
+            return uri;
+        const rendered = await loaded.ImageManipulator.manipulate(uri).renderAsync();
+        const saved = await rendered.saveAsync({ format: loaded.SaveFormat.PNG });
+        return saved.uri;
+    }
+    static load() {
+        try {
+            const loaded = require('expo-image-manipulator');
+            return typeof loaded.ImageManipulator.manipulate === 'function' ? loaded : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/services/ps-scan-output-service.d.ts

@@ -0,0 +1,10 @@
+import { PsScanFormat } from '../constants/ps-scan-format';
+import type { PsScannedFile } from '../interfaces/ps-scanned-file';
+export declare class PsScanOutputService {
+    static isAvailable(): boolean;
+    static produce(pages: PsScannedFile[], format: PsScanFormat, fileName: string): Promise<PsScannedFile[]>;
+    static pageName(base: string, index: number): string;
+    private static toPdf;
+    private static toPng;
+    private static loadFileSystem;
+}

package/dist/services/ps-scan-output-service.js

@@ -0,0 +1,55 @@
+import { PsScanFormat } from '../constants/ps-scan-format';
+import { PsScanOutputConfig } from '../constants/ps-scan-output-config';
+import { PsJpegSizeService } from './ps-jpeg-size-service';
+import { PsScanImageConverterService } from './ps-scan-image-converter-service';
+import { PsScanPdfService } from './ps-scan-pdf-service';
+export class PsScanOutputService {
+    static isAvailable() {
+        return (PsScanOutputService.loadFileSystem() !== null && PsScanImageConverterService.isAvailable());
+    }
+    static async produce(pages, format, fileName) {
+        return format === PsScanFormat.Pdf
+            ? [await PsScanOutputService.toPdf(pages, fileName)]
+            : PsScanOutputService.toPng(pages, fileName);
+    }
+    static pageName(base, index) {
+        return `${base}-${index + 1}.${PsScanOutputConfig.extensions[PsScanFormat.Png]}`;
+    }
+    static async toPdf(pages, fileName) {
+        const system = PsScanOutputService.loadFileSystem();
+        if (system === null)
+            throw new Error('expo-file-system is not available');
+        const loaded = [];
+        for (const page of pages) {
+            const bytes = new Uint8Array(await new system.File(page.uri).arrayBuffer());
+            const size = PsJpegSizeService.size(bytes);
+            if (size === null)
+                throw new Error('unreadable scan page');
+            loaded.push({ bytes, height: size.height, width: size.width });
+        }
+        const name = `${fileName}.${PsScanOutputConfig.extensions[PsScanFormat.Pdf]}`;
+        const file = new system.File(system.Paths.cache, `${Date.now()}-${name}`);
+        file.create({ overwrite: true });
+        await file.write(PsScanPdfService.fromJpegs(loaded));
+        return { name, type: PsScanOutputConfig.pdfType, uri: file.uri };
+    }
+    static async toPng(pages, fileName) {
+        const files = [];
+        for (const [index, page] of pages.entries())
+            files.push({
+                name: PsScanOutputService.pageName(fileName, index),
+                type: PsScanOutputConfig.pngType,
+                uri: await PsScanImageConverterService.toPng(page.uri),
+            });
+        return files;
+    }
+    static loadFileSystem() {
+        try {
+            const loaded = require('expo-file-system');
+            return typeof loaded.File === 'function' ? loaded : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { PsPdfPage } from '../interfaces/ps-pdf-page';
+export declare class PsScanPdfService {
+    static fromJpegs(pages: PsPdfPage[]): Uint8Array;
+}