@pallasoft/ps-mobile-components 1.3.0 → 1.5.0

package/dist/interfaces/ps-waterfall-step.d.ts

@@ -0,0 +1,7 @@
+export interface PsWaterfallStep {
+    end: number;
+    isTotal: boolean;
+    label: string;
+    start: number;
+    value: number;
+}

package/dist/interfaces/ps-waterfall-step.js

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

package/dist/interfaces/use-ps-barcode-scanner-result.d.ts

@@ -0,0 +1,6 @@
+export interface UsePsBarcodeScannerResult {
+    close: () => void;
+    isAvailable: boolean;
+    isOpen: boolean;
+    open: () => void;
+}

package/dist/interfaces/use-ps-barcode-scanner-result.js

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

package/dist/interfaces/use-ps-document-open-result.d.ts

@@ -0,0 +1,5 @@
+export interface UsePsDocumentOpenResult {
+    hasFailed: boolean;
+    isOpening: boolean;
+    open: () => Promise<void>;
+}

package/dist/interfaces/use-ps-document-open-result.js

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

package/dist/interfaces/use-ps-document-pdf-cover-result.d.ts

@@ -0,0 +1,7 @@
+import type { PsDocumentLoadStatus } from '../constants/ps-document-load-status';
+import type { PsDocumentPageImage } from './ps-document-page-image';
+export interface UsePsDocumentPdfCoverResult {
+    cover: PsDocumentPageImage | null;
+    retry: () => void;
+    status: PsDocumentLoadStatus;
+}

package/dist/interfaces/use-ps-document-pdf-cover-result.js

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

package/dist/interfaces/use-ps-document-pdf-pages-result.d.ts

@@ -0,0 +1,5 @@
+import type { PsDocumentPdfState } from './ps-document-pdf-state';
+export interface UsePsDocumentPdfPagesResult {
+    retry: () => void;
+    states: Record<string, PsDocumentPdfState>;
+}

package/dist/interfaces/use-ps-document-pdf-pages-result.js

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

package/dist/interfaces/use-ps-document-text-result.d.ts

@@ -0,0 +1,5 @@
+import type { PsDocumentLoadStatus } from '../constants/ps-document-load-status';
+export interface UsePsDocumentTextResult {
+    status: PsDocumentLoadStatus;
+    text: string | null;
+}

package/dist/interfaces/use-ps-document-text-result.js

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

package/dist/interfaces/use-ps-file-upload-result.d.ts

@@ -0,0 +1,8 @@
+import type { PsCaptureSource } from '../constants/ps-capture-source';
+import type { PsCaptureLabels } from './ps-capture-labels';
+import type { PsMenuItem } from './ps-menu-item';
+export interface UsePsFileUploadResult {
+    isUploading: boolean;
+    items: (labels: PsCaptureLabels, onPicked?: (source: PsCaptureSource) => void) => PsMenuItem[];
+    pick: (source: PsCaptureSource) => Promise<void>;
+}

package/dist/interfaces/use-ps-file-upload-result.js

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

package/dist/interfaces/use-ps-quick-actions-options.d.ts

@@ -0,0 +1,5 @@
+import type { PsQuickAction } from './ps-quick-action';
+export interface UsePsQuickActionsOptions {
+    items: PsQuickAction[];
+    onSelect: (id: string) => void;
+}

package/dist/interfaces/use-ps-quick-actions-options.js

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

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

@@ -0,0 +1,14 @@
+import type { ComponentType } from 'react';
+import type { PsBarcodeFrameSize } from '../interfaces/ps-barcode-frame-size';
+import type { PsBarcodeLastRead } from '../interfaces/ps-barcode-last-read';
+import type { PsBarcodeScannerCameraProps } from '../interfaces/ps-barcode-scanner-native';
+export declare class PsBarcodeScannerService {
+    static isAvailable(): boolean;
+    static camera(): ComponentType<PsBarcodeScannerCameraProps> | null;
+    static requestPermission(): Promise<boolean>;
+    static normalise(data: string): string;
+    static accept(previous: PsBarcodeLastRead | null, data: string, now: number): boolean;
+    static types(barcodeTypes?: string[]): string[];
+    static frameSize(width: number): PsBarcodeFrameSize;
+    private static load;
+}

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

@@ -0,0 +1,53 @@
+import { PsBarcodeScannerConfig } from '../constants/ps-barcode-scanner-config';
+export class PsBarcodeScannerService {
+    static isAvailable() {
+        return PsBarcodeScannerService.load() !== null;
+    }
+    static camera() {
+        const native = PsBarcodeScannerService.load();
+        return native === null ? null : native.CameraView;
+    }
+    static async requestPermission() {
+        const native = PsBarcodeScannerService.load();
+        if (native === null)
+            return false;
+        try {
+            const response = await native.Camera.requestCameraPermissionsAsync();
+            return response.granted;
+        }
+        catch {
+            return false;
+        }
+    }
+    static normalise(data) {
+        return data.trim();
+    }
+    static accept(previous, data, now) {
+        if (data === '')
+            return false;
+        if (previous === null)
+            return true;
+        return previous.data !== data || now - previous.at >= PsBarcodeScannerConfig.cooldownMs;
+    }
+    static types(barcodeTypes) {
+        return barcodeTypes === undefined || barcodeTypes.length === 0
+            ? PsBarcodeScannerConfig.barcodeTypes
+            : barcodeTypes;
+    }
+    static frameSize(width) {
+        const frameWidth = Math.round(width * PsBarcodeScannerConfig.frameWidthFraction);
+        return {
+            height: Math.round(frameWidth * PsBarcodeScannerConfig.frameAspectRatio),
+            width: frameWidth,
+        };
+    }
+    static load() {
+        try {
+            const loaded = require('expo-camera');
+            return typeof loaded.CameraView === 'function' ? loaded : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -1,6 +1,8 @@
+import { PsRippleKind } from '../constants/ps-ripple-kind';
 import type { PsButtonStyleData } from '../interfaces/ps-button-style-data';
 import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
 export type PsButtonVariant = 'danger' | 'ghost' | 'primary' | 'secondary' | 'surface';
 export declare class PsButtonStyleService {
+    static rippleKind(variant: PsButtonVariant): PsRippleKind;
     static resolve(variant: PsButtonVariant, theme: PsMobileTheme): PsButtonStyleData;
 }

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

@@ -1,6 +1,18 @@
 import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
+import { PsRippleKind } from '../constants/ps-ripple-kind';
 import { PsMobileColorService } from './ps-mobile-color-service';
+import { PsStateService } from './ps-state-service';
 export class PsButtonStyleService {
+    static rippleKind(variant) {
+        switch (variant) {
+            case 'primary':
+                return PsRippleKind.OnPrimary;
+            case 'danger':
+                return PsRippleKind.OnDanger;
+            default:
+                return PsRippleKind.Surface;
+        }
+    }
     static resolve(variant, theme) {
         const hover = PsMobileColorService.withAlpha(theme.primary, PsMobileControlConfig.pressedBorderAlpha);
         switch (variant) {
@@ -25,7 +37,7 @@ export class PsButtonStyleService {
                     background: theme.surface,
                     border: theme.line,
                     foreground: theme.ink,
-                    pressedBackground: PsMobileColorService.withAlpha(theme.ink, PsMobileControlConfig.pressedAlpha),
+                    pressedBackground: PsStateService.pressedFill(theme, theme.surface),
                     pressedBorder: hover,
                 };
         }

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

@@ -0,0 +1,12 @@
+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 pickRaw;
+    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,72 @@
+import { PsCaptureConfig } from '../constants/ps-capture-config';
+import { PsCaptureSource } from '../constants/ps-capture-source';
+import { PsDeviceFileBytesService } from './ps-device-file-bytes-service';
+import { PsDeviceFileService } from './ps-device-file-service';
+import { PsDocumentScannerService } from './ps-document-scanner-service';
+export class PsCapturePickerService {
+    static async pick(source, options = {}) {
+        const files = await PsCapturePickerService.pickRaw(source, options);
+        return files.map((file) => PsDeviceFileBytesService.withBytes(file));
+    }
+    static async pickRaw(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-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-bytes-service.d.ts

@@ -0,0 +1,6 @@
+import type { PsDeviceFile } from '../interfaces/ps-device-file';
+import type { PsFileOpener } from '../interfaces/ps-file-opener';
+export declare class PsDeviceFileBytesService {
+    static withBytes(file: PsDeviceFile, open?: PsFileOpener | null): PsDeviceFile;
+    private static opener;
+}

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

@@ -0,0 +1,19 @@
+export class PsDeviceFileBytesService {
+    static withBytes(file, open = PsDeviceFileBytesService.opener()) {
+        if (open === null)
+            return file;
+        return {
+            ...file,
+            bytes: async () => new Uint8Array(await open(file.uri).arrayBuffer()),
+        };
+    }
+    static opener() {
+        try {
+            const loaded = require('expo-file-system');
+            return typeof loaded.File === 'function' ? (uri) => new loaded.File(uri) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

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