@pallasoft/ps-mobile-components 1.7.0 → 1.8.1

package/dist/constants/ps-chart-config.js

@@ -1,31 +1,56 @@
 export const PsChartConfig = {
     areaOpacity: 0.18,
-    axisLabelSize: 10,
+    axisLabelGap: 8,
+    axisLabelMaxWidth: 48,
+    axisLabelSize: 11,
+    axisTickGap: 6,
     barGapRatio: 0.3,
     barRadius: 4,
+    charWidthRatio: 0.62,
+    compactBarGapRatio: 0.15,
+    compactSlot: 24,
     cardPadding: 16,
     cardRadius: 16,
     chartHeight: 180,
     deltaIconSize: 10,
     donutHeight: 160,
     donutThickness: 22,
+    donutCenterFontMax: 18,
+    donutCenterFontMin: 11,
+    donutCenterPadding: 8,
+    donutGap: 16,
+    donutMinLegendWidth: 120,
     donutSliceGap: 2,
     drawMs: 700,
+    ellipsis: '…',
     gridLineCount: 3,
     gridLineWidth: 1,
+    kpiDeltaHeight: 20,
     kpiGap: 12,
+    kpiPeriodHeight: 16,
+    kpiValueFontMax: 24,
+    kpiValueFontMin: 16,
+    legendHitSlop: 8,
     legendDot: 8,
     lineWidth: 2.5,
     markerRadius: 4,
+    minBarWidth: 4,
     maxXLabels: 4,
+    minXLabels: 2,
     paddingBottom: 22,
     paddingRight: 8,
     paddingTop: 8,
     readoutHeight: 40,
+    readoutItemGap: 12,
+    readoutLineHeight: 22,
+    readoutRowGap: 2,
+    readoutValueSize: 15,
     scrubLineWidth: 1,
     skeletonBarHeights: [0.45, 0.7, 0.55, 0.85, 0.65, 0.95, 0.75],
     skeletonPulseMs: 900,
     sparklineHeight: 40,
     sparklineWidth: 2,
+    yAxisMaxRatio: 0.35,
+    yAxisMinWidth: 28,
     yAxisWidth: 52,
 };

package/dist/constants/ps-screen-capture-config.d.ts

@@ -0,0 +1,4 @@
+export declare const PsScreenCaptureConfig: {
+    readonly key: "ps-mobile-components";
+    readonly moduleName: "expo-screen-capture";
+};

package/dist/constants/ps-screen-capture-config.js

@@ -0,0 +1,4 @@
+export const PsScreenCaptureConfig = {
+    key: 'ps-mobile-components',
+    moduleName: 'expo-screen-capture',
+};

package/dist/constants/ps-sortable-grid-config.d.ts

@@ -6,6 +6,7 @@ export declare const PsSortableGridConfig: {
     readonly holdTolerance: 8;
     readonly longPressMs: 400;
     readonly maxScrollStep: 18;
+    readonly measureTolerance: 1;
     readonly moveMs: 220;
     readonly outlineOffset: 0;
     readonly outlineWidth: 2;

package/dist/constants/ps-sortable-grid-config.js

@@ -8,6 +8,7 @@ export const PsSortableGridConfig = {
     holdTolerance: 8,
     longPressMs: 400,
     maxScrollStep: 18,
+    measureTolerance: 1,
     moveMs: 220,
     outlineOffset: 0,
     outlineWidth: 2,

package/dist/contexts/ps-widget-fill-context.d.ts

@@ -0,0 +1 @@
+export declare const PsWidgetFillContext: import("react").Context<number>;

package/dist/contexts/ps-widget-fill-context.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const PsWidgetFillContext = createContext(0);

package/dist/hooks/use-ps-screen-capture-prevention.d.ts

@@ -0,0 +1,2 @@
+import type { UsePsScreenCapturePreventionOptions } from '../interfaces/use-ps-screen-capture-prevention-options';
+export declare const usePsScreenCapturePrevention: ({ isEnabled, }?: UsePsScreenCapturePreventionOptions) => void;

package/dist/hooks/use-ps-screen-capture-prevention.js

@@ -0,0 +1,12 @@
+import { useEffect } from 'react';
+import { PsScreenCaptureService } from '../services/ps-screen-capture-service';
+export const usePsScreenCapturePrevention = ({ isEnabled = true, } = {}) => {
+    useEffect(() => {
+        if (!isEnabled)
+            return;
+        void PsScreenCaptureService.prevent();
+        return () => {
+            void PsScreenCaptureService.allow();
+        };
+    }, [isEnabled]);
+};

package/dist/hooks/use-ps-widget-fill.d.ts

@@ -0,0 +1 @@
+export declare const usePsWidgetFill: () => number;

package/dist/hooks/use-ps-widget-fill.js

@@ -0,0 +1,3 @@
+import { useContext } from 'react';
+import { PsWidgetFillContext } from '../contexts/ps-widget-fill-context';
+export const usePsWidgetFill = () => useContext(PsWidgetFillContext);

package/dist/index.d.ts

@@ -146,10 +146,14 @@ export * from './interfaces/ps-text-variant';
 export * from './interfaces/ps-sheet-action';
 export * from './interfaces/ps-sheet-leading-kind';
 export * from './interfaces/ps-sheet-page';
+export * from './components/ps-accessibility-gate';
 export * from './components/ps-app-lock-screen';
 export * from './components/ps-privacy-cover';
 export * from './constants/ps-biometry-kind';
 export * from './hooks/use-ps-app-lock';
+export * from './hooks/use-ps-screen-capture-prevention';
+export * from './interfaces/use-ps-screen-capture-prevention-options';
+export { PsScreenCaptureService } from './services/ps-screen-capture-service';
 export * from './interfaces/ps-app-lock-prompt';
 export * from './interfaces/use-ps-app-lock-options';
 export * from './interfaces/use-ps-app-lock-result';

package/dist/index.js

@@ -141,10 +141,14 @@ export * from './interfaces/ps-text-variant';
 export * from './interfaces/ps-sheet-action';
 export * from './interfaces/ps-sheet-leading-kind';
 export * from './interfaces/ps-sheet-page';
+export * from './components/ps-accessibility-gate';
 export * from './components/ps-app-lock-screen';
 export * from './components/ps-privacy-cover';
 export * from './constants/ps-biometry-kind';
 export * from './hooks/use-ps-app-lock';
+export * from './hooks/use-ps-screen-capture-prevention';
+export * from './interfaces/use-ps-screen-capture-prevention-options';
+export { PsScreenCaptureService } from './services/ps-screen-capture-service';
 export * from './interfaces/ps-app-lock-prompt';
 export * from './interfaces/use-ps-app-lock-options';
 export * from './interfaces/use-ps-app-lock-result';

package/dist/interfaces/ps-chart-bar-group.d.ts

@@ -0,0 +1,4 @@
+export interface PsChartBarGroup {
+    offset: number;
+    width: number;
+}

package/dist/interfaces/ps-chart-bar-group.js

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

package/dist/interfaces/ps-chart-x-labels.d.ts

@@ -0,0 +1,4 @@
+export interface PsChartXLabels {
+    indexes: number[];
+    maxWidth: number;
+}

package/dist/interfaces/ps-chart-x-labels.js

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

package/dist/interfaces/ps-donut-chart-layout.d.ts

@@ -0,0 +1,4 @@
+export interface PsDonutChartLayout {
+    isStacked: boolean;
+    size: number;
+}

package/dist/interfaces/ps-donut-chart-layout.js

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

package/dist/interfaces/ps-screen-capture-native.d.ts

@@ -0,0 +1,4 @@
+export interface PsScreenCaptureNative {
+    allowScreenCaptureAsync: (key?: string) => Promise<void>;
+    preventScreenCaptureAsync: (key?: string) => Promise<void>;
+}

package/dist/interfaces/ps-screen-capture-native.js

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

package/dist/interfaces/use-ps-screen-capture-prevention-options.d.ts

@@ -0,0 +1,3 @@
+export interface UsePsScreenCapturePreventionOptions {
+    isEnabled?: boolean;
+}

package/dist/interfaces/use-ps-screen-capture-prevention-options.js

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

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

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

@@ -1,4 +1,3 @@
-import { PsChartConfig } from '../constants/ps-chart-config';
 import { PsChartBarService } from './ps-chart-bar-service';
 import { PsChartScaleService } from './ps-chart-scale-service';
 export class PsWaterfallService {
@@ -20,7 +19,7 @@ export class PsWaterfallService {
     }
     static rects(steps, colors, domain, plot) {
         const slot = PsChartBarService.slot(steps.length, plot);
-        const width = slot * (1 - PsChartConfig.barGapRatio);
+        const { offset, width } = PsChartBarService.group(slot, 1);
         return steps.map((step, row) => {
             const from = PsChartScaleService.y(step.start, domain, plot);
             const to = PsChartScaleService.y(step.end, domain, plot);
@@ -30,7 +29,7 @@ export class PsWaterfallService {
                 id: `${row}:${step.label}`,
                 isNegative: step.end < step.start,
                 width,
-                x: plot.left + row * slot + (slot * PsChartConfig.barGapRatio) / 2,
+                x: plot.left + row * slot + offset,
                 y: Math.min(from, to),
             };
         });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pallasoft/ps-mobile-components",
-	"version": "1.7.0",
+	"version": "1.8.1",
 	"private": false,
 	"description": "Native iOS (SwiftUI) and Android (Jetpack Compose) Ps components for Pallasoft mobile apps",
 	"main": "./dist/index.js",
@@ -53,6 +53,7 @@
 		"expo-local-authentication": "~58.0.0",
 		"expo-quick-actions": "^6.0.2",
 		"expo-router": "~58.0.0",
+		"expo-screen-capture": "~58.0.0",
 		"react": "^19.3.0",
 		"react-native": "~0.88.0",
 		"react-native-document-scanner-plugin": "^2.0.4",
@@ -90,6 +91,9 @@
 		"expo-router": {
 			"optional": true
 		},
+		"expo-screen-capture": {
+			"optional": true
+		},
 		"react-native-document-scanner-plugin": {
 			"optional": true
 		},