@pallasoft/ps-mobile-components 1.10.2 → 1.12.0

package/dist/interfaces/ps-document-search-state.d.ts

@@ -0,0 +1,4 @@
+export interface PsDocumentSearchState {
+    activeIndex: number;
+    query: string;
+}

package/dist/interfaces/ps-document-search-state.js

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

package/dist/interfaces/ps-document-text-box.d.ts

@@ -0,0 +1,6 @@
+export interface PsDocumentTextBox {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}

package/dist/interfaces/ps-document-text-box.js

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

package/dist/interfaces/ps-document-text-layer-word.d.ts

@@ -0,0 +1,5 @@
+import type { PsDocumentTextBox } from './ps-document-text-box';
+export interface PsDocumentTextLayerWord {
+    box: PsDocumentTextBox;
+    text: string;
+}

package/dist/interfaces/ps-document-text-layer-word.js

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

package/dist/interfaces/ps-document-text-layer.d.ts

@@ -0,0 +1,6 @@
+import type { PsDocumentTextLayerWord } from './ps-document-text-layer-word';
+export interface PsDocumentTextLayer {
+    height: number;
+    width: number;
+    words: PsDocumentTextLayerWord[];
+}

package/dist/interfaces/ps-document-text-layer.js

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

package/dist/interfaces/ps-document-text-line.d.ts

@@ -0,0 +1,4 @@
+export interface PsDocumentTextLine {
+    text: string;
+    y: number;
+}

package/dist/interfaces/ps-document-text-line.js

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

package/dist/interfaces/ps-document-text-segment.d.ts

@@ -0,0 +1,4 @@
+export interface PsDocumentTextSegment {
+    matchIndex: number | null;
+    text: string;
+}

package/dist/interfaces/ps-document-text-segment.js

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

package/dist/interfaces/ps-document-word-match.d.ts

@@ -0,0 +1,3 @@
+export interface PsDocumentWordMatch {
+    wordIndices: number[];
+}

package/dist/interfaces/ps-document-word-match.js

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

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

@@ -2,6 +2,7 @@ import type { PsInfinitePage } from './ps-infinite-page';
 export interface PsInfiniteDataOptions<T> {
     getKey: (item: T) => string;
     isEnabled?: boolean;
+    keepPreviousOnKeyChange?: boolean | ((previousKey: string, nextKey: string) => boolean);
     key: string;
     loadPage: (cursor: string | null) => Promise<PsInfinitePage<T>>;
     onSettled?: () => Promise<unknown>;

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

@@ -5,6 +5,7 @@ export interface PsInfiniteDataResult<T> {
     hasMore: boolean;
     isLoading: boolean;
     isLoadingMore: boolean;
+    isRefreshing: boolean;
     items: T[];
     loadMore: () => Promise<void>;
     refresh: () => Promise<void>;

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

@@ -0,0 +1,4 @@
+export interface PsMenuPopupInsets {
+    bottom: number;
+    top: number;
+}

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

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

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

@@ -7,5 +7,4 @@ export declare class PsChartSeriesService {
     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

@@ -28,7 +28,4 @@ export class PsChartSeriesService {
     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-document-search-service.d.ts

@@ -0,0 +1,40 @@
+import type { PsDocumentHighlightRect } from '../interfaces/ps-document-highlight-rect';
+import type { PsDocumentItem } from '../interfaces/ps-document-item';
+import type { PsDocumentLabels } from '../interfaces/ps-document-labels';
+import type { PsDocumentNormalizedText } from '../interfaces/ps-document-normalized-text';
+import type { PsDocumentPoint } from '../interfaces/ps-document-point';
+import type { PsDocumentSearchLabels } from '../interfaces/ps-document-search-labels';
+import type { PsDocumentSearchLocation } from '../interfaces/ps-document-search-location';
+import type { PsDocumentSearchMatch } from '../interfaces/ps-document-search-match';
+import type { PsDocumentTextBox } from '../interfaces/ps-document-text-box';
+import type { PsDocumentTextLayer } from '../interfaces/ps-document-text-layer';
+import type { PsDocumentTextLine } from '../interfaces/ps-document-text-line';
+import type { PsDocumentTextSegment } from '../interfaces/ps-document-text-segment';
+import type { PsDocumentViewerEntry } from '../interfaces/ps-document-viewer-entry';
+import type { PsDocumentWordMatch } from '../interfaces/ps-document-word-match';
+import type { PsSize } from '../interfaces/ps-size';
+export declare class PsDocumentSearchService {
+    static normalize(text: string): PsDocumentNormalizedText;
+    static terms(query: string): string[];
+    static matches(text: string, query: string): PsDocumentSearchMatch[];
+    static segments(text: string, matches: PsDocumentSearchMatch[]): PsDocumentTextSegment[];
+    static joinedWords(layer: PsDocumentTextLayer): string;
+    static wordMatches(layer: PsDocumentTextLayer, query: string): PsDocumentWordMatch[];
+    static fit(layer: PsDocumentTextLayer, container: PsSize): PsDocumentTextBox;
+    static rect(box: PsDocumentTextBox, layer: PsDocumentTextLayer, container: PsSize): PsDocumentTextBox;
+    static highlights(layer: PsDocumentTextLayer, query: string, container: PsSize, activeIndex: number): PsDocumentHighlightRect[];
+    static center(box: PsDocumentTextBox): PsDocumentPoint;
+    static scrollOffset(lines: PsDocumentTextLine[], start: number): number;
+    static entryMatchCount(entry: PsDocumentViewerEntry, texts: Record<string, string>, query: string): number;
+    static counts(entries: PsDocumentViewerEntry[], texts: Record<string, string>, query: string): number[];
+    static total(counts: number[]): number;
+    static locate(counts: number[], active: number): PsDocumentSearchLocation | null;
+    static activeFor(counts: number[], active: number, entryIndex: number): number;
+    static firstIndexOf(counts: number[], entryIndex: number): number;
+    static step(active: number, total: number, direction: 1 | -1): number;
+    static startIndex(counts: number[], entryIndex: number): number;
+    static countLabel(template: string, current: number, total: number): string;
+    static labels(labels: PsDocumentLabels): PsDocumentSearchLabels | null;
+    static isSearchable(items: PsDocumentItem[]): boolean;
+    private static merge;
+}

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

@@ -0,0 +1,201 @@
+import { PsDocumentKind } from '../constants/ps-document-kind';
+import { PsDocumentSearchConfig } from '../constants/ps-document-search-config';
+export class PsDocumentSearchService {
+    static normalize(text) {
+        const starts = [];
+        const ends = [];
+        let value = '';
+        let offset = 0;
+        for (const character of Array.from(text)) {
+            const folded = character
+                .normalize('NFD')
+                .replace(PsDocumentSearchConfig.combiningMarkPattern, '')
+                .toLowerCase();
+            for (let position = 0; position < folded.length; position += 1) {
+                starts.push(offset);
+                ends.push(offset + character.length);
+            }
+            value += folded;
+            offset += character.length;
+        }
+        return { ends, starts, value };
+    }
+    static terms(query) {
+        return PsDocumentSearchService.normalize(query)
+            .value.split(PsDocumentSearchConfig.termSeparatorPattern)
+            .filter((term) => term !== '');
+    }
+    static matches(text, query) {
+        const terms = PsDocumentSearchService.terms(query);
+        if (terms.length === 0)
+            return [];
+        const normalized = PsDocumentSearchService.normalize(text);
+        const ranges = [];
+        for (const term of terms) {
+            let from = normalized.value.indexOf(term);
+            while (from >= 0) {
+                ranges.push({ end: from + term.length, start: from });
+                from = normalized.value.indexOf(term, from + term.length);
+            }
+        }
+        return PsDocumentSearchService.merge(ranges).map((range) => ({
+            end: normalized.ends[range.end - 1],
+            start: normalized.starts[range.start],
+        }));
+    }
+    static segments(text, matches) {
+        const segments = [];
+        let cursor = 0;
+        matches.forEach((match, index) => {
+            if (match.start > cursor)
+                segments.push({ matchIndex: null, text: text.slice(cursor, match.start) });
+            segments.push({ matchIndex: index, text: text.slice(match.start, match.end) });
+            cursor = match.end;
+        });
+        if (cursor < text.length)
+            segments.push({ matchIndex: null, text: text.slice(cursor) });
+        return segments;
+    }
+    static joinedWords(layer) {
+        return layer.words.map((word) => word.text).join(PsDocumentSearchConfig.wordSeparator);
+    }
+    static wordMatches(layer, query) {
+        const matches = PsDocumentSearchService.matches(PsDocumentSearchService.joinedWords(layer), query);
+        const bounds = [];
+        let cursor = 0;
+        for (const word of layer.words) {
+            bounds.push({ end: cursor + word.text.length, start: cursor });
+            cursor += word.text.length + PsDocumentSearchConfig.wordSeparator.length;
+        }
+        return matches.map((match) => ({
+            wordIndices: bounds.flatMap((bound, index) => bound.start < match.end && bound.end > match.start ? [index] : []),
+        }));
+    }
+    static fit(layer, container) {
+        if (layer.width <= 0 || layer.height <= 0)
+            return { height: 0, left: 0, top: 0, width: 0 };
+        const scale = Math.min(container.width / layer.width, container.height / layer.height);
+        const width = layer.width * scale;
+        const height = layer.height * scale;
+        return {
+            height,
+            left: (container.width - width) / 2,
+            top: (container.height - height) / 2,
+            width,
+        };
+    }
+    static rect(box, layer, container) {
+        const fitted = PsDocumentSearchService.fit(layer, container);
+        const scale = layer.width <= 0 ? 0 : fitted.width / layer.width;
+        return {
+            height: box.height * scale,
+            left: fitted.left + box.left * scale,
+            top: fitted.top + box.top * scale,
+            width: box.width * scale,
+        };
+    }
+    static highlights(layer, query, container, activeIndex) {
+        return PsDocumentSearchService.wordMatches(layer, query).flatMap((match, matchIndex) => match.wordIndices.map((wordIndex) => ({
+            box: PsDocumentSearchService.rect(layer.words[wordIndex].box, layer, container),
+            isActive: matchIndex === activeIndex,
+        })));
+    }
+    static center(box) {
+        return { x: box.left + box.width / 2, y: box.top + box.height / 2 };
+    }
+    static scrollOffset(lines, start) {
+        let cursor = 0;
+        for (const line of lines) {
+            cursor += line.text.length;
+            if (start < cursor)
+                return line.y;
+        }
+        const last = lines[lines.length - 1];
+        return last === undefined ? 0 : last.y;
+    }
+    static entryMatchCount(entry, texts, query) {
+        if (entry.item.kind === PsDocumentKind.Text) {
+            const text = entry.item.text === null ? texts[entry.item.id] : entry.item.text;
+            return text === undefined ? 0 : PsDocumentSearchService.matches(text, query).length;
+        }
+        const layer = entry.item.textLayer;
+        return layer === undefined ? 0 : PsDocumentSearchService.wordMatches(layer, query).length;
+    }
+    static counts(entries, texts, query) {
+        return entries.map((entry) => PsDocumentSearchService.entryMatchCount(entry, texts, query));
+    }
+    static total(counts) {
+        return counts.reduce((sum, count) => sum + count, 0);
+    }
+    static locate(counts, active) {
+        let remaining = active;
+        for (let entryIndex = 0; entryIndex < counts.length; entryIndex += 1) {
+            if (remaining < counts[entryIndex])
+                return { entryIndex, localIndex: remaining };
+            remaining -= counts[entryIndex];
+        }
+        return null;
+    }
+    static activeFor(counts, active, entryIndex) {
+        const location = PsDocumentSearchService.locate(counts, active);
+        return location !== null && location.entryIndex === entryIndex
+            ? location.localIndex
+            : PsDocumentSearchConfig.noActive;
+    }
+    static firstIndexOf(counts, entryIndex) {
+        return counts.slice(0, entryIndex).reduce((sum, count) => sum + count, 0);
+    }
+    static step(active, total, direction) {
+        if (total <= 0)
+            return PsDocumentSearchConfig.noActive;
+        return (active + direction + total) % total;
+    }
+    static startIndex(counts, entryIndex) {
+        const total = PsDocumentSearchService.total(counts);
+        if (total === 0)
+            return PsDocumentSearchConfig.noActive;
+        return counts[entryIndex] > 0 ? PsDocumentSearchService.firstIndexOf(counts, entryIndex) : 0;
+    }
+    static countLabel(template, current, total) {
+        return template
+            .replace(PsDocumentSearchConfig.currentToken, String(current))
+            .replace(PsDocumentSearchConfig.totalToken, String(total));
+    }
+    static labels(labels) {
+        const { closeSearch, matchCount, nextMatch, noMatches, previousMatch, search, searchPlaceholder, } = labels;
+        if (closeSearch === undefined ||
+            matchCount === undefined ||
+            nextMatch === undefined ||
+            noMatches === undefined ||
+            previousMatch === undefined ||
+            search === undefined ||
+            searchPlaceholder === undefined)
+            return null;
+        return {
+            closeSearch,
+            matchCount,
+            nextMatch,
+            noMatches,
+            previousMatch,
+            search,
+            searchPlaceholder,
+        };
+    }
+    static isSearchable(items) {
+        return items.some((item) => (item.kind === PsDocumentKind.Text && (item.text !== null || item.source !== null)) ||
+            item.textLayer !== undefined ||
+            (item.pageTextLayers !== undefined && item.pageTextLayers.length > 0));
+    }
+    static merge(ranges) {
+        const sorted = [...ranges].sort((a, b) => a.start === b.start ? a.end - b.end : a.start - b.start);
+        const merged = [];
+        for (const range of sorted) {
+            const last = merged[merged.length - 1];
+            if (last !== undefined && range.start < last.end)
+                merged[merged.length - 1] = { end: Math.max(last.end, range.end), start: last.start };
+            else
+                merged.push({ ...range });
+        }
+        return merged;
+    }
+}

package/dist/services/ps-document-search-style-service.d.ts

@@ -0,0 +1,7 @@
+import type { TextStyle, ViewStyle } from 'react-native';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsDocumentSearchStyleService {
+    static span(theme: PsMobileTheme, isActive: boolean): TextStyle;
+    static rect(theme: PsMobileTheme, isActive: boolean): ViewStyle;
+    static fieldRadius(isMaterial: boolean): number;
+}

package/dist/services/ps-document-search-style-service.js

@@ -0,0 +1,22 @@
+import { PsDocumentSearchConfig } from '../constants/ps-document-search-config';
+import { PsMobileColorService } from './ps-mobile-color-service';
+export class PsDocumentSearchStyleService {
+    static span(theme, isActive) {
+        return isActive
+            ? { backgroundColor: theme.primary, color: theme.primaryContrast }
+            : {
+                backgroundColor: PsMobileColorService.withAlpha(theme.primary, PsDocumentSearchConfig.highlightAlpha),
+            };
+    }
+    static rect(theme, isActive) {
+        return {
+            backgroundColor: PsMobileColorService.withAlpha(theme.primary, isActive ? PsDocumentSearchConfig.activeAlpha : PsDocumentSearchConfig.highlightAlpha),
+            borderRadius: PsDocumentSearchConfig.highlightRadius,
+        };
+    }
+    static fieldRadius(isMaterial) {
+        return isMaterial
+            ? PsDocumentSearchConfig.androidFieldRadius
+            : PsDocumentSearchConfig.iosFieldRadius;
+    }
+}

package/dist/services/ps-document-viewer-entry-service.js

@@ -63,6 +63,7 @@ export class PsDocumentViewerEntryService {
                     name: item.name,
                     source: { headers: {}, uri: page.uri },
                     text: null,
+                    textLayer: item.pageTextLayers === undefined ? undefined : item.pageTextLayers[index],
                 },
                 sourceId: item.id,
                 status: PsDocumentLoadStatus.Ready,

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

@@ -1,5 +1,6 @@
 export declare class PsDocumentZoomService {
     static clampAxis(value: number, container: number, scale: number): number;
+    static centerOffset(point: number, container: number, scale: number): number;
     static clampScale(scale: number): number;
     static dragOffset(translationY: number): number;
     static focalOffset(tap: number, container: number, scale: number): number;

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

@@ -4,6 +4,9 @@ export class PsDocumentZoomService {
         const limit = (container * (scale - 1)) / 2;
         return Math.min(limit, Math.max(-limit, value));
     }
+    static centerOffset(point, container, scale) {
+        return PsDocumentZoomService.clampAxis((container / 2 - point) * scale, container, scale);
+    }
     static clampScale(scale) {
         return Math.min(PsDocumentConfig.maxZoom, Math.max(PsDocumentConfig.minZoom, scale));
     }

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

@@ -4,5 +4,6 @@ export declare class PsInfiniteDataService {
     static initial<T>(): PsInfiniteDataState<T>;
     static merge<T>(existing: T[], incoming: T[], getKey: (item: T) => string): T[];
     static apply<T>(rows: T[], updates: PsInfiniteDataUpdate<T>[]): T[];
+    static keepsPrevious(option: boolean | ((previousKey: string, nextKey: string) => boolean), previousKey: string, nextKey: string): boolean;
     static hasMore<T>(state: PsInfiniteDataState<T>): boolean;
 }

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

@@ -16,6 +16,9 @@ export class PsInfiniteDataService {
     static apply(rows, updates) {
         return updates.reduce((current, update) => update(current), rows);
     }
+    static keepsPrevious(option, previousKey, nextKey) {
+        return typeof option === 'boolean' ? option : option(previousKey, nextKey);
+    }
     static hasMore(state) {
         return state.nextCursor !== null;
     }

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

@@ -1,6 +1,7 @@
 import type { PsMenuAnchor } from '../interfaces/ps-menu-anchor';
+import type { PsMenuPopupInsets } from '../interfaces/ps-menu-popup-insets';
 import type { PsMenuPopupLayout } from '../interfaces/ps-menu-popup-layout';
 import type { PsMenuPopupWindow } from '../interfaces/ps-menu-popup-window';
 export declare class PsMenuPopupService {
-    static layout(anchor: PsMenuAnchor, window: PsMenuPopupWindow, contentHeight: number, contentWidth: number, isFullWidth: boolean): PsMenuPopupLayout;
+    static layout(anchor: PsMenuAnchor, window: PsMenuPopupWindow, insets: PsMenuPopupInsets, contentHeight: number, contentWidth: number, isFullWidth: boolean): PsMenuPopupLayout;
 }

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

@@ -1,12 +1,12 @@
 import { PsMenuPopupConfig } from '../constants/ps-menu-popup-config';
 export class PsMenuPopupService {
-    static layout(anchor, window, contentHeight, contentWidth, isFullWidth) {
+    static layout(anchor, window, insets, contentHeight, contentWidth, isFullWidth) {
         const margin = PsMenuPopupConfig.edgeMargin;
         const gap = PsMenuPopupConfig.anchorGap;
         const width = isFullWidth ? anchor.width : undefined;
         const menuWidth = width === undefined ? contentWidth : width;
-        const below = window.height - (anchor.y + anchor.height) - gap - margin;
-        const above = anchor.y - gap - margin;
+        const below = window.height - (anchor.y + anchor.height) - gap - Math.max(margin, insets.bottom);
+        const above = anchor.y - gap - Math.max(margin, insets.top);
         const isBelow = contentHeight <= below || below >= above;
         const room = isBelow ? below : above;
         const height = Math.min(contentHeight, Math.max(room, 0));

package/dist/services/ps-sheet-service.d.ts

@@ -6,6 +6,7 @@ export declare class PsSheetService {
     static handlesInset(os: string): boolean;
     static bottomPadding(isFloating: boolean, bottomInset: number): number;
     static fittedHeight(headerHeight: number, bodyHeight: number, windowHeight: number): number;
+    static raisedHeight(height: number, keyboardHeight: number, windowHeight: number, topInset: number): number;
     static closeAction(label: string | undefined, onPress: () => void): PsSheetAction | undefined;
     static isActionInactive(action: PsSheetAction): boolean;
     static actionOpacity(action: PsSheetAction, isPressed: boolean): number;

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

@@ -13,6 +13,9 @@ export class PsSheetService {
     static fittedHeight(headerHeight, bodyHeight, windowHeight) {
         return Math.min(Math.ceil(headerHeight + bodyHeight), PsSheetService.maxHeight(windowHeight));
     }
+    static raisedHeight(height, keyboardHeight, windowHeight, topInset) {
+        return Math.min(height + keyboardHeight, windowHeight - topInset);
+    }
     static closeAction(label, onPress) {
         return label === undefined ? undefined : { label, onPress };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pallasoft/ps-mobile-components",
-	"version": "1.10.2",
+	"version": "1.12.0",
 	"private": false,
 	"description": "Native iOS (SwiftUI) and Android (Jetpack Compose) Ps components for Pallasoft mobile apps",
 	"main": "./dist/index.js",