@pallasoft/ps-mobile-components 1.6.0 → 1.8.0

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

@@ -0,0 +1,5 @@
+import type { PsChartXLabels } from '../interfaces/ps-chart-x-labels';
+export declare class PsChartAxisService {
+    static yAxisWidth(labels: string[], width: number): number;
+    static xLabels(labels: string[], available: number, isBand: boolean): PsChartXLabels;
+}

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

@@ -0,0 +1,32 @@
+import { PsChartConfig } from '../constants/ps-chart-config';
+import { PsChartTextService } from './ps-chart-text-service';
+export class PsChartAxisService {
+    static yAxisWidth(labels, width) {
+        if (width <= 0)
+            return PsChartConfig.yAxisWidth;
+        const wanted = PsChartTextService.widest(labels, PsChartConfig.axisLabelSize) + PsChartConfig.axisTickGap;
+        return Math.min(Math.max(Math.ceil(wanted), PsChartConfig.yAxisMinWidth), Math.max(width * PsChartConfig.yAxisMaxRatio, PsChartConfig.yAxisMinWidth));
+    }
+    static xLabels(labels, available, isBand) {
+        const count = labels.length;
+        const all = Array.from({ length: count }, (_, index) => index);
+        if (count === 0 || available <= 0)
+            return { indexes: [], maxWidth: 0 };
+        const wanted = Math.min(PsChartTextService.widest(labels, PsChartConfig.axisLabelSize), PsChartConfig.axisLabelMaxWidth) + PsChartConfig.axisLabelGap;
+        if (isBand) {
+            const pitch = available / count;
+            const step = Math.max(Math.ceil(wanted / pitch), 1);
+            return {
+                indexes: all.filter((index) => index % step === 0),
+                maxWidth: Math.max(pitch * step - PsChartConfig.axisLabelGap, 0),
+            };
+        }
+        if (count === 1)
+            return { indexes: all, maxWidth: available };
+        const shown = Math.min(Math.max(Math.floor(available / wanted) + 1, PsChartConfig.minXLabels), count);
+        return {
+            indexes: Array.from({ length: shown }, (_, index) => Math.round((index * (count - 1)) / (shown - 1))),
+            maxWidth: Math.max(available / (shown - 1) - PsChartConfig.axisLabelGap, 0),
+        };
+    }
+}

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

@@ -1,5 +1,6 @@
 import type { PsAreaChartDatum } from '../interfaces/ps-area-chart-datum';
 import type { PsCartesianChartSeries } from '../interfaces/ps-cartesian-chart-series';
+import type { PsChartBarGroup } from '../interfaces/ps-chart-bar-group';
 import type { PsChartBarRect } from '../interfaces/ps-chart-bar-rect';
 import type { PsChartDomain } from '../interfaces/ps-chart-domain';
 import type { PsChartPlot } from '../interfaces/ps-chart-plot';
@@ -7,5 +8,6 @@ export declare class PsChartBarService {
     static grouped(data: PsAreaChartDatum[], series: PsCartesianChartSeries[], colors: string[], domain: PsChartDomain, plot: PsChartPlot): PsChartBarRect[];
     static stacked(data: PsAreaChartDatum[], series: PsCartesianChartSeries[], colors: string[], domain: PsChartDomain, plot: PsChartPlot): PsChartBarRect[];
     static slot(count: number, plot: PsChartPlot): number;
+    static group(slot: number, size: number): PsChartBarGroup;
     private static rect;
 }

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

@@ -4,18 +4,18 @@ import { PsChartSeriesService } from './ps-chart-series-service';
 export class PsChartBarService {
     static grouped(data, series, colors, domain, plot) {
         const slot = PsChartBarService.slot(data.length, plot);
-        const width = (slot * (1 - PsChartConfig.barGapRatio)) / series.length;
+        const { offset, width } = PsChartBarService.group(slot, series.length);
         const zero = PsChartScaleService.y(0, domain, plot);
         return data.flatMap((datum, row) => series.map((entry, column) => {
             const value = PsChartSeriesService.value(datum, entry.dataKey);
             const top = PsChartScaleService.y(value, domain, plot);
-            const left = plot.left + row * slot + (slot * PsChartConfig.barGapRatio) / 2 + column * width;
+            const left = plot.left + row * slot + offset + column * width;
             return PsChartBarService.rect(`${row}:${entry.dataKey}`, colors[column], left, width, zero, top, value < 0);
         }));
     }
     static stacked(data, series, colors, domain, plot) {
         const slot = PsChartBarService.slot(data.length, plot);
-        const width = slot * (1 - PsChartConfig.barGapRatio);
+        const { offset, width } = PsChartBarService.group(slot, 1);
         return data.flatMap((datum, row) => {
             let positive = 0;
             let negative = 0;
@@ -27,13 +27,20 @@ export class PsChartBarService {
                     negative = to;
                 else
                     positive = to;
-                return PsChartBarService.rect(`${row}:${entry.dataKey}`, colors[column], plot.left + row * slot + (slot * PsChartConfig.barGapRatio) / 2, width, PsChartScaleService.y(from, domain, plot), PsChartScaleService.y(to, domain, plot), value < 0);
+                return PsChartBarService.rect(`${row}:${entry.dataKey}`, colors[column], plot.left + row * slot + offset, width, PsChartScaleService.y(from, domain, plot), PsChartScaleService.y(to, domain, plot), value < 0);
             });
         });
     }
     static slot(count, plot) {
         return (plot.right - plot.left) / Math.max(count, 1);
     }
+    static group(slot, size) {
+        const gap = slot < PsChartConfig.compactSlot
+            ? PsChartConfig.compactBarGapRatio
+            : PsChartConfig.barGapRatio;
+        const total = Math.max(slot * (1 - gap), Math.min(PsChartConfig.minBarWidth * size, slot));
+        return { offset: (slot - total) / 2, width: total / size };
+    }
     static rect(id, color, x, width, from, to, isNegative) {
         return {
             color,

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

@@ -1,6 +1,9 @@
 import type { PsDonutChartDatum } from '../interfaces/ps-donut-chart-datum';
+import type { PsDonutChartLayout } from '../interfaces/ps-donut-chart-layout';
 import type { PsDonutSliceData } from '../interfaces/ps-donut-slice-data';
 export declare class PsChartDonutService {
+    static layout(width: number, height: number): PsDonutChartLayout;
+    static centerFontSize(text: string, size: number): number;
     static radius(size: number): number;
     static circumference(size: number): number;
     static slices(data: PsDonutChartDatum[], colors: string[], size: number): PsDonutSliceData[];

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

@@ -1,5 +1,16 @@
 import { PsChartConfig } from '../constants/ps-chart-config';
+import { PsChartTextService } from './ps-chart-text-service';
 export class PsChartDonutService {
+    static layout(width, height) {
+        const side = height + PsChartConfig.donutGap + PsChartConfig.donutMinLegendWidth;
+        if (width >= side)
+            return { isStacked: false, size: height };
+        return { isStacked: true, size: Math.min(height, Math.max(width, 0)) };
+    }
+    static centerFontSize(text, size) {
+        const inner = size - 2 * (PsChartConfig.donutThickness + PsChartConfig.donutCenterPadding);
+        return PsChartTextService.fontSize(text, Math.max(inner, 0), PsChartConfig.donutCenterFontMax, PsChartConfig.donutCenterFontMin);
+    }
     static radius(size) {
         return (size - PsChartConfig.donutThickness) / 2;
     }

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

@@ -4,4 +4,7 @@ import type { PsChartReadoutItem } from '../interfaces/ps-chart-readout-item';
 export declare class PsChartReadoutService {
     static items(datum: PsAreaChartDatum, series: PsCartesianChartSeries[], colors: string[], formatValue: (value: number) => string): PsChartReadoutItem[];
     static summary(title: string, items: PsChartReadoutItem[]): string;
+    static lines(items: PsChartReadoutItem[], width: number): number;
+    static maxLines(rows: PsChartReadoutItem[][], width: number): number;
+    static height(lines: number): number;
 }

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

@@ -1,4 +1,6 @@
+import { PsChartConfig } from '../constants/ps-chart-config';
 import { PsChartSeriesService } from './ps-chart-series-service';
+import { PsChartTextService } from './ps-chart-text-service';
 export class PsChartReadoutService {
     static items(datum, series, colors, formatValue) {
         return series.map((entry, index) => ({
@@ -10,4 +12,27 @@ export class PsChartReadoutService {
     static summary(title, items) {
         return [title, ...items.map((item) => `${item.label} ${item.value}`)].join(', ');
     }
+    static lines(items, width) {
+        let lines = 1;
+        let used = 0;
+        items.forEach((item) => {
+            const wanted = PsChartConfig.legendDot +
+                PsChartConfig.axisTickGap +
+                PsChartTextService.estimateWidth(item.value, PsChartConfig.readoutValueSize);
+            if (used > 0 && used + PsChartConfig.readoutItemGap + wanted > width) {
+                lines += 1;
+                used = wanted;
+                return;
+            }
+            used += used > 0 ? PsChartConfig.readoutItemGap + wanted : wanted;
+        });
+        return lines;
+    }
+    static maxLines(rows, width) {
+        return rows.reduce((most, row) => Math.max(most, PsChartReadoutService.lines(row, width)), 1);
+    }
+    static height(lines) {
+        return (PsChartConfig.readoutHeight +
+            (Math.max(lines, 1) - 1) * (PsChartConfig.readoutLineHeight + PsChartConfig.readoutRowGap));
+    }
 }

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

@@ -1,7 +1,7 @@
 import type { PsChartDomain } from '../interfaces/ps-chart-domain';
 import type { PsChartPlot } from '../interfaces/ps-chart-plot';
 export declare class PsChartScaleService {
-    static plot(width: number, height: number): PsChartPlot;
+    static plot(width: number, height: number, yAxisWidth?: number): PsChartPlot;
     static sparkPlot(width: number, height: number): PsChartPlot;
     static domain(values: number[]): PsChartDomain;
     static spanDomain(values: number[]): PsChartDomain;

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

@@ -1,9 +1,9 @@
 import { PsChartConfig } from '../constants/ps-chart-config';
 export class PsChartScaleService {
-    static plot(width, height) {
+    static plot(width, height, yAxisWidth = PsChartConfig.yAxisWidth) {
         return {
             bottom: height - PsChartConfig.paddingBottom,
-            left: PsChartConfig.yAxisWidth,
+            left: yAxisWidth,
             right: width - PsChartConfig.paddingRight,
             top: PsChartConfig.paddingTop,
         };

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

@@ -0,0 +1,6 @@
+export declare class PsChartTextService {
+    static estimateWidth(text: string, fontSize: number): number;
+    static widest(texts: string[], fontSize: number): number;
+    static fit(text: string, maxWidth: number, fontSize: number): string;
+    static fontSize(text: string, maxWidth: number, largest: number, smallest: number): number;
+}

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

@@ -0,0 +1,23 @@
+import { PsChartConfig } from '../constants/ps-chart-config';
+export class PsChartTextService {
+    static estimateWidth(text, fontSize) {
+        return text.length * fontSize * PsChartConfig.charWidthRatio;
+    }
+    static widest(texts, fontSize) {
+        return texts.reduce((widest, text) => Math.max(widest, PsChartTextService.estimateWidth(text, fontSize)), 0);
+    }
+    static fit(text, maxWidth, fontSize) {
+        if (PsChartTextService.estimateWidth(text, fontSize) <= maxWidth)
+            return text;
+        const characters = Math.floor(maxWidth / (fontSize * PsChartConfig.charWidthRatio));
+        if (characters < 1)
+            return '';
+        return `${text.slice(0, Math.max(characters - 1, 1))}${PsChartConfig.ellipsis}`;
+    }
+    static fontSize(text, maxWidth, largest, smallest) {
+        if (PsChartTextService.estimateWidth(text, largest) <= maxWidth)
+            return largest;
+        const fitted = Math.floor(maxWidth / (text.length * PsChartConfig.charWidthRatio));
+        return Math.min(Math.max(fitted, smallest), largest);
+    }
+}

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

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

@@ -0,0 +1,6 @@
+import { Common } from '@pallasoft/ps-utilities';
+export class PsScanPdfService {
+    static fromJpegs(pages) {
+        return Common.JpegPdfService.fromJpegs(pages);
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { PsScreenCaptureNative } from '../interfaces/ps-screen-capture-native';
+export declare class PsScreenCaptureService {
+    static load(): PsScreenCaptureNative | null;
+    static prevent(): Promise<boolean>;
+    static allow(): Promise<void>;
+}

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

@@ -0,0 +1,35 @@
+import { PsScreenCaptureConfig } from '../constants/ps-screen-capture-config';
+export class PsScreenCaptureService {
+    static load() {
+        try {
+            const loaded = require('expo-screen-capture');
+            return typeof loaded.preventScreenCaptureAsync === 'function' ? loaded : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static async prevent() {
+        const native = PsScreenCaptureService.load();
+        if (native === null)
+            return false;
+        try {
+            await native.preventScreenCaptureAsync(PsScreenCaptureConfig.key);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async allow() {
+        const native = PsScreenCaptureService.load();
+        if (native === null)
+            return;
+        try {
+            await native.allowScreenCaptureAsync(PsScreenCaptureConfig.key);
+        }
+        catch {
+            return;
+        }
+    }
+}

package/dist/services/ps-sortable-grid-service.d.ts

@@ -10,6 +10,8 @@ export declare class PsSortableGridService {
     static isSameOrder(first: string[], second: string[]): boolean;
     static rows(spans: PsSortableGridSpan[]): number[][];
     static layout(spans: PsSortableGridSpan[], heights: number[], width: number): PsSortableRect[];
+    static extras(rects: PsSortableRect[], heights: number[]): number[];
+    static natural(total: number, extra: number): number;
     static contentHeight(rects: PsSortableRect[]): number;
     static indexAt(rects: PsSortableRect[], x: number, y: number, current: number): number;
     static move<T>(items: T[], from: number, to: number): T[];

package/dist/services/ps-sortable-grid-service.js

@@ -35,19 +35,26 @@ export class PsSortableGridService {
         const rects = [];
         let top = 0;
         PsSortableGridService.rows(spans).forEach((row) => {
+            const rowHeight = Math.max(...row.map((index) => heights[index]));
             row.forEach((index, column) => {
-                const isHalf = spans[index] === PsSortableGridSpan.half;
+                const isHalf = spans[index] === PsSortableGridSpan.half && row.length === 2;
                 rects[index] = {
-                    height: heights[index],
+                    height: rowHeight,
                     width: isHalf ? half : width,
                     x: column === 0 ? 0 : half + PsSortableGridConfig.columnGap,
                     y: top,
                 };
             });
-            top += Math.max(...row.map((index) => heights[index])) + PsSortableGridConfig.rowGap;
+            top += rowHeight + PsSortableGridConfig.rowGap;
         });
         return rects;
     }
+    static extras(rects, heights) {
+        return rects.map((rect, index) => Math.max(rect.height - heights[index], 0));
+    }
+    static natural(total, extra) {
+        return Math.max(total - extra, 0);
+    }
     static contentHeight(rects) {
         return rects.reduce((bottom, rect) => Math.max(bottom, rect.y + rect.height), 0);
     }