@pallasoft/ps-mobile-components 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,23 @@
+import { PallasoftBackdropConfig } from '@pallasoft/ps-design-system';
+export class PsBackdropService {
+    static verticalOffsets(width) {
+        const count = Math.floor(width / PallasoftBackdropConfig.gridSize);
+        return Array.from({ length: count + 1 }, (_, index) => index * PallasoftBackdropConfig.gridSize);
+    }
+    static horizontalLines(height) {
+        const fadeHeight = height * PallasoftBackdropConfig.gridFadeStop;
+        const count = Math.floor(fadeHeight / PallasoftBackdropConfig.gridSize);
+        return Array.from({ length: count + 1 }, (_, index) => {
+            const offset = index * PallasoftBackdropConfig.gridSize;
+            return {
+                offset,
+                opacity: PallasoftBackdropConfig.gridLineOpacity *
+                    PallasoftBackdropConfig.gridFadeOpacity *
+                    (1 - offset / fadeHeight),
+            };
+        });
+    }
+    static fadeHeight(height) {
+        return height * PallasoftBackdropConfig.gridFadeStop;
+    }
+}

package/dist/services/ps-badge-tone-service.d.ts

@@ -0,0 +1,6 @@
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+import type { PsToneColors } from '../interfaces/ps-tone-colors';
+export type PsBadgeTone = 'danger' | 'neutral' | 'primary' | 'success' | 'warning';
+export declare class PsBadgeToneService {
+    static resolve(tone: PsBadgeTone, theme: PsMobileTheme): PsToneColors;
+}

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

@@ -0,0 +1,21 @@
+import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
+import { PsMobileColorService } from './ps-mobile-color-service';
+export class PsBadgeToneService {
+    static resolve(tone, theme) {
+        switch (tone) {
+            case 'danger':
+                return { background: theme.dangerSoft, foreground: theme.danger };
+            case 'primary':
+                return { background: theme.primarySoft, foreground: theme.ink };
+            case 'success':
+                return { background: theme.successSoft, foreground: theme.success };
+            case 'warning':
+                return { background: theme.warningSoft, foreground: theme.warning };
+            default:
+                return {
+                    background: PsMobileColorService.withAlpha(theme.ink, PsMobileControlConfig.neutralAlpha),
+                    foreground: theme.ink,
+                };
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+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 resolve(variant: PsButtonVariant, theme: PsMobileTheme): PsButtonStyleData;
+}

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

@@ -0,0 +1,33 @@
+import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
+import { PsMobileColorService } from './ps-mobile-color-service';
+export class PsButtonStyleService {
+    static resolve(variant, theme) {
+        const hover = PsMobileColorService.withAlpha(theme.primary, PsMobileControlConfig.pressedBorderAlpha);
+        switch (variant) {
+            case 'primary':
+                return {
+                    background: theme.primary,
+                    border: theme.primary,
+                    foreground: theme.primaryContrast,
+                    pressedBackground: theme.primary,
+                    pressedBorder: theme.primary,
+                };
+            case 'danger':
+                return {
+                    background: theme.danger,
+                    border: theme.danger,
+                    foreground: theme.white,
+                    pressedBackground: theme.danger,
+                    pressedBorder: theme.danger,
+                };
+            default:
+                return {
+                    background: theme.surface,
+                    border: theme.line,
+                    foreground: theme.ink,
+                    pressedBackground: PsMobileColorService.withAlpha(theme.ink, PsMobileControlConfig.pressedAlpha),
+                    pressedBorder: hover,
+                };
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { PsAreaChartDatum } from '../interfaces/ps-area-chart-datum';
+import type { PsCartesianChartSeries } from '../interfaces/ps-cartesian-chart-series';
+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';
+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;
+    private static rect;
+}

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

@@ -0,0 +1,48 @@
+import { PsChartConfig } from '../constants/ps-chart-config';
+import { PsChartScaleService } from './ps-chart-scale-service';
+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 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;
+            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);
+        return data.flatMap((datum, row) => {
+            let positive = 0;
+            let negative = 0;
+            return series.map((entry, column) => {
+                const value = PsChartSeriesService.value(datum, entry.dataKey);
+                const from = value < 0 ? negative : positive;
+                const to = from + value;
+                if (value < 0)
+                    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);
+            });
+        });
+    }
+    static slot(count, plot) {
+        return (plot.right - plot.left) / Math.max(count, 1);
+    }
+    static rect(id, color, x, width, from, to, isNegative) {
+        return {
+            color,
+            height: Math.abs(to - from),
+            id,
+            isNegative,
+            width,
+            x,
+            y: Math.min(from, to),
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+import { PsChartDeltaTone } from '../constants/ps-chart-delta';
+import type { PsChartDeltaColors } from '../interfaces/ps-chart-delta-colors';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsChartDeltaService {
+    static colors(tone: PsChartDeltaTone, theme: PsMobileTheme): PsChartDeltaColors;
+}

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

@@ -0,0 +1,10 @@
+import { PsChartDeltaTone } from '../constants/ps-chart-delta';
+export class PsChartDeltaService {
+    static colors(tone, theme) {
+        if (tone === PsChartDeltaTone.Positive)
+            return { background: theme.successSoft, foreground: theme.success };
+        if (tone === PsChartDeltaTone.Negative)
+            return { background: theme.dangerSoft, foreground: theme.danger };
+        return { background: theme.accentSoft, foreground: theme.muted };
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { PsDonutChartDatum } from '../interfaces/ps-donut-chart-datum';
+import type { PsDonutSliceData } from '../interfaces/ps-donut-slice-data';
+export declare class PsChartDonutService {
+    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

@@ -0,0 +1,28 @@
+import { PsChartConfig } from '../constants/ps-chart-config';
+export class PsChartDonutService {
+    static radius(size) {
+        return (size - PsChartConfig.donutThickness) / 2;
+    }
+    static circumference(size) {
+        return 2 * Math.PI * PsChartDonutService.radius(size);
+    }
+    static slices(data, colors, size) {
+        const circumference = PsChartDonutService.circumference(size);
+        const total = data.reduce((sum, datum) => sum + datum.share, 0);
+        if (total <= 0)
+            return [];
+        let start = 0;
+        return data.map((datum, index) => {
+            const length = (datum.share / total) * circumference;
+            const slice = {
+                color: colors[index % colors.length],
+                dashLength: Math.max(length - PsChartConfig.donutSliceGap, 0),
+                dashOffset: -start,
+                id: datum.id,
+                start,
+            };
+            start += length;
+            return slice;
+        });
+    }
+}

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

@@ -0,0 +1,6 @@
+import { PsCartesianChartKind } from '../constants/ps-chart-kind';
+import { PsChartSkeletonVariant } from '../constants/ps-chart-skeleton-variant';
+export declare class PsChartKindService {
+    static skeletonVariant(kind: PsCartesianChartKind): PsChartSkeletonVariant;
+    static isBars(kind: PsCartesianChartKind): boolean;
+}

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

@@ -0,0 +1,12 @@
+import { PsCartesianChartKind } from '../constants/ps-chart-kind';
+import { PsChartSkeletonVariant } from '../constants/ps-chart-skeleton-variant';
+export class PsChartKindService {
+    static skeletonVariant(kind) {
+        return kind === PsCartesianChartKind.Area || kind === PsCartesianChartKind.Line
+            ? PsChartSkeletonVariant.Line
+            : PsChartSkeletonVariant.Bars;
+    }
+    static isBars(kind) {
+        return kind === PsCartesianChartKind.Bar || kind === PsCartesianChartKind.StackedBar;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { PsChartPoint } from '../interfaces/ps-chart-point';
+export declare class PsChartPathService {
+    static line(points: PsChartPoint[]): string;
+    static area(points: PsChartPoint[], baseline: number): string;
+    static measure(points: PsChartPoint[]): number;
+}

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

@@ -0,0 +1,22 @@
+export class PsChartPathService {
+    static line(points) {
+        return points
+            .map((point, index) => `${index === 0 ? 'M' : 'L'}${point.x} ${point.y}`)
+            .join(' ');
+    }
+    static area(points, baseline) {
+        if (points.length === 0)
+            return '';
+        const first = points[0];
+        const last = points[points.length - 1];
+        return `${PsChartPathService.line(points)} L${last.x} ${baseline} L${first.x} ${baseline} Z`;
+    }
+    static measure(points) {
+        return points.reduce((total, point, index) => {
+            if (index === 0)
+                return total;
+            const before = points[index - 1];
+            return total + Math.hypot(point.x - before.x, point.y - before.y);
+        }, 0);
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { PsAreaChartDatum } from '../interfaces/ps-area-chart-datum';
+import type { PsCartesianChartSeries } from '../interfaces/ps-cartesian-chart-series';
+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;
+}

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

@@ -0,0 +1,13 @@
+import { PsChartSeriesService } from './ps-chart-series-service';
+export class PsChartReadoutService {
+    static items(datum, series, colors, formatValue) {
+        return series.map((entry, index) => ({
+            color: colors[index],
+            label: entry.label,
+            value: formatValue(PsChartSeriesService.value(datum, entry.dataKey)),
+        }));
+    }
+    static summary(title, items) {
+        return [title, ...items.map((item) => `${item.label} ${item.value}`)].join(', ');
+    }
+}

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

@@ -0,0 +1,15 @@
+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 sparkPlot(width: number, height: number): PsChartPlot;
+    static domain(values: number[]): PsChartDomain;
+    static spanDomain(values: number[]): PsChartDomain;
+    static ticks(domain: PsChartDomain): number[];
+    static y(value: number, domain: PsChartDomain, plot: PsChartPlot): number;
+    static x(index: number, count: number, plot: PsChartPlot): number;
+    static labelIndexes(count: number): number[];
+    static categoryX(position: number, count: number, plot: PsChartPlot, isBand: boolean): number;
+    static labelAnchor(position: number, count: number, isBand: boolean): 'end' | 'middle' | 'start';
+    private static niceStep;
+}

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

@@ -0,0 +1,76 @@
+import { PsChartConfig } from '../constants/ps-chart-config';
+export class PsChartScaleService {
+    static plot(width, height) {
+        return {
+            bottom: height - PsChartConfig.paddingBottom,
+            left: PsChartConfig.yAxisWidth,
+            right: width - PsChartConfig.paddingRight,
+            top: PsChartConfig.paddingTop,
+        };
+    }
+    static sparkPlot(width, height) {
+        return {
+            bottom: height - PsChartConfig.sparklineWidth,
+            left: PsChartConfig.sparklineWidth,
+            right: width - PsChartConfig.sparklineWidth,
+            top: PsChartConfig.sparklineWidth,
+        };
+    }
+    static domain(values) {
+        const low = Math.min(0, ...values);
+        const high = Math.max(0, ...values);
+        if (low === 0 && high === 0)
+            return { max: 1, min: 0, step: 1 };
+        const step = PsChartScaleService.niceStep((high - low) / PsChartConfig.gridLineCount);
+        return { max: Math.ceil(high / step) * step, min: Math.floor(low / step) * step, step };
+    }
+    static spanDomain(values) {
+        const low = Math.min(...values);
+        const high = Math.max(...values);
+        if (low === high)
+            return { max: high + 1, min: low - 1, step: 1 };
+        return { max: high, min: low, step: high - low };
+    }
+    static ticks(domain) {
+        const count = Math.round((domain.max - domain.min) / domain.step);
+        return Array.from({ length: count + 1 }, (_, index) => domain.min + index * domain.step);
+    }
+    static y(value, domain, plot) {
+        const ratio = (domain.max - value) / (domain.max - domain.min);
+        return plot.top + ratio * (plot.bottom - plot.top);
+    }
+    static x(index, count, plot) {
+        if (count <= 1)
+            return (plot.left + plot.right) / 2;
+        return plot.left + (index / (count - 1)) * (plot.right - plot.left);
+    }
+    static labelIndexes(count) {
+        if (count <= PsChartConfig.maxXLabels)
+            return Array.from({ length: count }, (_, index) => index);
+        const last = PsChartConfig.maxXLabels - 1;
+        return Array.from({ length: PsChartConfig.maxXLabels }, (_, index) => Math.round((index * (count - 1)) / last));
+    }
+    static categoryX(position, count, plot, isBand) {
+        if (!isBand)
+            return PsChartScaleService.x(position, count, plot);
+        return plot.left + ((plot.right - plot.left) / Math.max(count, 1)) * (position + 0.5);
+    }
+    static labelAnchor(position, count, isBand) {
+        if (isBand || count <= 1)
+            return 'middle';
+        if (position === 0)
+            return 'start';
+        return position === count - 1 ? 'end' : 'middle';
+    }
+    static niceStep(raw) {
+        const magnitude = Math.pow(10, Math.floor(Math.log10(raw)));
+        const normalized = raw / magnitude;
+        if (normalized <= 1)
+            return magnitude;
+        if (normalized <= 2)
+            return 2 * magnitude;
+        if (normalized <= 5)
+            return 5 * magnitude;
+        return 10 * magnitude;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { PsChartPlot } from '../interfaces/ps-chart-plot';
+export declare class PsChartScrubService {
+    static pointIndex(x: number, plot: PsChartPlot, count: number): number;
+    static bandIndex(x: number, plot: PsChartPlot, count: number): number;
+    private static clamp;
+}

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

@@ -0,0 +1,17 @@
+export class PsChartScrubService {
+    static pointIndex(x, plot, count) {
+        if (count <= 1)
+            return 0;
+        const ratio = (x - plot.left) / (plot.right - plot.left);
+        return PsChartScrubService.clamp(Math.round(ratio * (count - 1)), count);
+    }
+    static bandIndex(x, plot, count) {
+        if (count <= 1)
+            return 0;
+        const ratio = (x - plot.left) / (plot.right - plot.left);
+        return PsChartScrubService.clamp(Math.floor(ratio * count), count);
+    }
+    static clamp(index, count) {
+        return Math.min(Math.max(index, 0), count - 1);
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { PsAreaChartDatum } from '../interfaces/ps-area-chart-datum';
+import type { PsCartesianChartSeries } from '../interfaces/ps-cartesian-chart-series';
+import type { PsChartPaletteInput } from '../interfaces/ps-chart-palette-input';
+export declare class PsChartSeriesService {
+    static value(datum: PsAreaChartDatum, dataKey: string): number;
+    static values(data: PsAreaChartDatum[], series: PsCartesianChartSeries[]): number[];
+    static stackedValues(data: PsAreaChartDatum[], series: PsCartesianChartSeries[]): number[];
+    static color({ count, explicit, index, theme }: PsChartPaletteInput): string;
+    static isEmpty(data: PsAreaChartDatum[], series: PsCartesianChartSeries[]): boolean;
+    static signature(kind: string, data: PsAreaChartDatum[], series: PsCartesianChartSeries[]): string;
+}

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

@@ -0,0 +1,34 @@
+export class PsChartSeriesService {
+    static value(datum, dataKey) {
+        const value = datum[dataKey];
+        return typeof value === 'number' ? value : 0;
+    }
+    static values(data, series) {
+        return data.flatMap((datum) => series.map((entry) => PsChartSeriesService.value(datum, entry.dataKey)));
+    }
+    static stackedValues(data, series) {
+        return data.flatMap((datum) => {
+            const amounts = series.map((entry) => PsChartSeriesService.value(datum, entry.dataKey));
+            const positive = amounts
+                .filter((amount) => amount > 0)
+                .reduce((sum, amount) => sum + amount, 0);
+            const negative = amounts
+                .filter((amount) => amount < 0)
+                .reduce((sum, amount) => sum + amount, 0);
+            return [positive, negative];
+        });
+    }
+    static color({ count, explicit, index, theme }) {
+        if (explicit !== undefined)
+            return explicit;
+        if (count === 1)
+            return theme.primary;
+        return theme.chart[index % theme.chart.length];
+    }
+    static isEmpty(data, series) {
+        return PsChartSeriesService.values(data, series).every((value) => value === 0);
+    }
+    static signature(kind, data, series) {
+        return `${kind}:${PsChartSeriesService.values(data, series).join(',')}`;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { MenuAction } from '@react-native-menu/menu';
+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[];
+}

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

@@ -0,0 +1,17 @@
+import { PsActionMenuService } from './ps-action-menu-service';
+export class PsContextMenuService {
+    static actions(items, theme, hasSymbols) {
+        const consistent = PsActionMenuService.consistent([{ id: 'items', items }]);
+        const entries = consistent.length === 0 ? [] : consistent[0].items;
+        return entries.map((item) => ({
+            attributes: {
+                destructive: item.isDanger === true,
+                disabled: item.isDisabled === true,
+            },
+            id: item.id,
+            image: hasSymbols ? PsActionMenuService.symbol(item) : undefined,
+            imageColor: item.isDanger === true ? theme.danger : theme.ink,
+            title: item.label,
+        }));
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { TextStyle, ViewStyle } from 'react-native';
+import type { PsControlState } from '../interfaces/ps-control-state';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsControlStyleService {
+    static container(theme: PsMobileTheme, state: PsControlState): ViewStyle;
+    static border(theme: PsMobileTheme, state: PsControlState): string;
+    static input(theme: PsMobileTheme): TextStyle;
+}

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

@@ -0,0 +1,35 @@
+import { PsMobileControlConfig } from '../constants/ps-mobile-control-config';
+export class PsControlStyleService {
+    static container(theme, state) {
+        return {
+            alignItems: 'center',
+            backgroundColor: theme.surface,
+            borderColor: PsControlStyleService.border(theme, state),
+            borderRadius: PsMobileControlConfig.controlRadius,
+            borderWidth: 1,
+            flexDirection: 'row',
+            minHeight: PsMobileControlConfig.controlHeights.default,
+            opacity: state.isDisabled ? PsMobileControlConfig.disabledOpacity : 1,
+            outlineColor: state.isFocused ? theme.primary : undefined,
+            outlineOffset: state.isFocused ? PsMobileControlConfig.ringOffset : undefined,
+            outlineStyle: state.isFocused ? 'solid' : undefined,
+            outlineWidth: state.isFocused ? PsMobileControlConfig.ringWidth : undefined,
+            paddingHorizontal: PsMobileControlConfig.controlPaddingX.default,
+        };
+    }
+    static border(theme, state) {
+        if (state.hasError)
+            return theme.danger;
+        return state.isFocused ? theme.primary : theme.line;
+    }
+    static input(theme) {
+        return {
+            color: theme.ink,
+            flex: 1,
+            fontFamily: theme.fonts.regular,
+            fontSize: PsMobileControlConfig.controlFontSize,
+            minHeight: PsMobileControlConfig.controlHeights.default,
+            padding: 0,
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare class PsDateFieldService {
+    static isValid(value: string): boolean;
+    static toLocalDate(value: string): Date;
+    static fromLocalDate(date: Date): string;
+    static fromUtcDate(date: Date): string;
+}

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

@@ -0,0 +1,18 @@
+import { Common } from '@pallasoft/ps-utilities';
+import { PsDateFieldConfig } from '../constants/ps-date-field-config';
+export class PsDateFieldService {
+    static isValid(value) {
+        if (!PsDateFieldConfig.valuePattern.test(value))
+            return false;
+        return Common.DateService.formatDate(value, PsDateFieldConfig.isoFormat) === value;
+    }
+    static toLocalDate(value) {
+        return Common.DateService.getDate(value).toDate();
+    }
+    static fromLocalDate(date) {
+        return Common.DateService.formatDate(date.getTime(), PsDateFieldConfig.isoFormat);
+    }
+    static fromUtcDate(date) {
+        return Common.DateService.formatDateInTimezone(date.getTime(), PsDateFieldConfig.utcZone, PsDateFieldConfig.isoFormat);
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { PsDateLimits } from '../interfaces/ps-date-limits';
+export declare class PsDatePickerService {
+    static limits(min: string | undefined, max: string | undefined): PsDateLimits;
+    static clamp(value: string, min: string | undefined, max: string | undefined): string;
+}

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

@@ -0,0 +1,16 @@
+import { PsDateFieldService } from './ps-date-field-service';
+export class PsDatePickerService {
+    static limits(min, max) {
+        return {
+            end: max === undefined ? undefined : PsDateFieldService.toLocalDate(max),
+            start: min === undefined ? undefined : PsDateFieldService.toLocalDate(min),
+        };
+    }
+    static clamp(value, min, max) {
+        if (min !== undefined && value < min)
+            return min;
+        if (max !== undefined && value > max)
+            return max;
+        return value;
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { PsDateRange, PsDateRangeEdge } from '../components/ps-date-range-field/ps-date-range-field-props';
+export declare class PsDateRangeService {
+    static change(range: PsDateRange, edge: PsDateRangeEdge, iso: string): PsDateRange;
+}

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

@@ -0,0 +1,7 @@
+export class PsDateRangeService {
+    static change(range, edge, iso) {
+        if (edge === 'from')
+            return { from: iso, to: iso > range.to ? iso : range.to };
+        return { from: iso < range.from ? iso : range.from, to: iso };
+    }
+}

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

@@ -0,0 +1,7 @@
+export declare class PsDocumentPagerService {
+    static clampIndex(index: number, count: number): number;
+    static counter(index: number, count: number): string;
+    static hasMany(count: number): boolean;
+    static offset(index: number, width: number): number;
+    static pageIndex(offsetX: number, width: number, count: number): number;
+}

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

@@ -0,0 +1,18 @@
+import { PsDocumentConfig } from '../constants/ps-document-config';
+export class PsDocumentPagerService {
+    static clampIndex(index, count) {
+        return Math.max(0, Math.min(count - 1, index));
+    }
+    static counter(index, count) {
+        return `${index + 1}${PsDocumentConfig.counterSeparator}${count}`;
+    }
+    static hasMany(count) {
+        return count > 1;
+    }
+    static offset(index, width) {
+        return index * width;
+    }
+    static pageIndex(offsetX, width, count) {
+        return width <= 0 ? 0 : PsDocumentPagerService.clampIndex(Math.round(offsetX / width), count);
+    }
+}

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

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