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

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

@@ -0,0 +1,19 @@
+import { PsSortableGridSpan } from '../constants/ps-sortable-grid-span';
+import type { PsSortableRect } from '../interfaces/ps-sortable-rect';
+export declare class PsSortableGridService {
+    static halfWidth(width: number): number;
+    static heights(ids: string[], measured: Record<string, number>): number[];
+    static isMeasured(ids: string[], measured: Record<string, number>, width: number): boolean;
+    static ids<T extends {
+        id: string;
+    }>(items: T[]): string[];
+    static isSameOrder(first: string[], second: string[]): boolean;
+    static rows(spans: PsSortableGridSpan[]): number[][];
+    static layout(spans: PsSortableGridSpan[], heights: number[], width: number): PsSortableRect[];
+    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[];
+    static scrollStep(absoluteY: number, top: number, bottom: number, zone: number): number;
+    static clampOffset(offset: number, minimum: number, content: number, viewport: number): number;
+    private static distance;
+}

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

@@ -0,0 +1,89 @@
+import { PsSortableGridConfig } from '../constants/ps-sortable-grid-config';
+import { PsSortableGridSpan } from '../constants/ps-sortable-grid-span';
+export class PsSortableGridService {
+    static halfWidth(width) {
+        return Math.max((width - PsSortableGridConfig.columnGap) / 2, 0);
+    }
+    static heights(ids, measured) {
+        return ids.map((id) => (measured[id] === undefined ? 0 : measured[id]));
+    }
+    static isMeasured(ids, measured, width) {
+        return width > 0 && ids.every((id) => measured[id] !== undefined);
+    }
+    static ids(items) {
+        return items.map((item) => item.id);
+    }
+    static isSameOrder(first, second) {
+        return first.length === second.length && first.every((id, index) => id === second[index]);
+    }
+    static rows(spans) {
+        return spans.reduce((rows, span, index) => {
+            const last = rows[rows.length - 1];
+            const canJoin = span === PsSortableGridSpan.half &&
+                last !== undefined &&
+                last.length === 1 &&
+                spans[last[0]] === PsSortableGridSpan.half;
+            if (canJoin)
+                last.push(index);
+            else
+                rows.push([index]);
+            return rows;
+        }, []);
+    }
+    static layout(spans, heights, width) {
+        const half = PsSortableGridService.halfWidth(width);
+        const rects = [];
+        let top = 0;
+        PsSortableGridService.rows(spans).forEach((row) => {
+            row.forEach((index, column) => {
+                const isHalf = spans[index] === PsSortableGridSpan.half;
+                rects[index] = {
+                    height: heights[index],
+                    width: isHalf ? half : width,
+                    x: column === 0 ? 0 : half + PsSortableGridConfig.columnGap,
+                    y: top,
+                };
+            });
+            top += Math.max(...row.map((index) => heights[index])) + PsSortableGridConfig.rowGap;
+        });
+        return rects;
+    }
+    static contentHeight(rects) {
+        return rects.reduce((bottom, rect) => Math.max(bottom, rect.y + rect.height), 0);
+    }
+    static indexAt(rects, x, y, current) {
+        const inside = rects.findIndex((rect) => x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height);
+        if (inside !== -1)
+            return inside;
+        if (rects.length === 0)
+            return current;
+        return rects.reduce((nearest, rect, index) => PsSortableGridService.distance(rect, x, y) <
+            PsSortableGridService.distance(rects[nearest], x, y)
+            ? index
+            : nearest, 0);
+    }
+    static move(items, from, to) {
+        if (from === to || from < 0 || to < 0 || from >= items.length || to >= items.length)
+            return items;
+        const next = items.slice();
+        const [moved] = next.splice(from, 1);
+        next.splice(to, 0, moved);
+        return next;
+    }
+    static scrollStep(absoluteY, top, bottom, zone) {
+        const reach = Math.max(zone, 1);
+        if (absoluteY < top)
+            return -Math.ceil(PsSortableGridConfig.maxScrollStep *
+                Math.min((top - absoluteY) / reach + PsSortableGridConfig.scrollRamp, 1));
+        if (absoluteY > bottom)
+            return Math.ceil(PsSortableGridConfig.maxScrollStep *
+                Math.min((absoluteY - bottom) / reach + PsSortableGridConfig.scrollRamp, 1));
+        return 0;
+    }
+    static clampOffset(offset, minimum, content, viewport) {
+        return Math.min(Math.max(offset, minimum), Math.max(content - viewport, minimum));
+    }
+    static distance(rect, x, y) {
+        return Math.hypot(rect.x + rect.width / 2 - x, rect.y + rect.height / 2 - y);
+    }
+}

package/dist/services/ps-statement-table-service.d.ts

@@ -0,0 +1,18 @@
+import type { PsStatementAlign, PsStatementColumn, PsStatementRow } from '../components/ps-statement-table/ps-statement-table-props';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+import type { PsStatementSection } from '../interfaces/ps-statement-section';
+export declare class PsStatementTableService {
+    static sections(rows: PsStatementRow[]): PsStatementSection[];
+    static labelStyle(): {
+        flex: number;
+        minWidth: number;
+    };
+    static columnWidth(column: PsStatementColumn): number;
+    static width(columns: PsStatementColumn[]): number;
+    static fitWidth(containerWidth: number, contentWidth: number): number;
+    static align(column: PsStatementColumn): PsStatementAlign;
+    static indent(row: PsStatementRow): number;
+    static isStrong(row: PsStatementRow): boolean;
+    static color(row: PsStatementRow, theme: PsMobileTheme): string;
+    static value(row: PsStatementRow, index: number): string;
+}

package/dist/services/ps-statement-table-service.js

@@ -0,0 +1,52 @@
+import { PsStatementTableConfig } from '../constants/ps-statement-table-config';
+export class PsStatementTableService {
+    static sections(rows) {
+        const sections = [];
+        for (const row of rows) {
+            if (row.emphasis === 'heading') {
+                sections.push({ data: [], heading: row, key: row.key });
+                continue;
+            }
+            const current = sections[sections.length - 1];
+            if (current === undefined)
+                sections.push({ data: [row], heading: null, key: row.key });
+            else
+                current.data.push(row);
+        }
+        return sections;
+    }
+    static labelStyle() {
+        return { flex: 1, minWidth: PsStatementTableConfig.labelMinWidth };
+    }
+    static columnWidth(column) {
+        return column.width === undefined ? PsStatementTableConfig.columnWidth : column.width;
+    }
+    static width(columns) {
+        return (PsStatementTableConfig.labelMinWidth +
+            PsStatementTableConfig.gutter * 2 +
+            columns.reduce((sum, column) => sum + PsStatementTableService.columnWidth(column), 0));
+    }
+    static fitWidth(containerWidth, contentWidth) {
+        return Math.max(containerWidth, contentWidth);
+    }
+    static align(column) {
+        return column.align === undefined ? 'right' : column.align;
+    }
+    static indent(row) {
+        return (row.level === undefined ? 0 : row.level) * PsStatementTableConfig.indentStep;
+    }
+    static isStrong(row) {
+        return row.emphasis === 'heading' || row.emphasis === 'subtotal' || row.emphasis === 'total';
+    }
+    static color(row, theme) {
+        const tone = row.tone === undefined ? 'neutral' : row.tone;
+        if (tone === 'danger')
+            return theme.danger;
+        if (tone === 'success')
+            return theme.success;
+        return row.emphasis === 'muted' ? theme.muted : theme.ink;
+    }
+    static value(row, index) {
+        return index < row.values.length ? row.values[index] : '';
+    }
+}

package/dist/services/ps-swipe-action-service.d.ts

@@ -0,0 +1,8 @@
+import type { PsMenuItem } from '../interfaces/ps-menu-item';
+import type { PsMenuItemTone } from '../interfaces/ps-menu-item-tone';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+export declare class PsSwipeActionService {
+    static tone(item: PsMenuItem): PsMenuItemTone;
+    static background(item: PsMenuItem, theme: PsMobileTheme): string;
+    static foreground(item: PsMenuItem, theme: PsMobileTheme): string;
+}

package/dist/services/ps-swipe-action-service.js

@@ -0,0 +1,20 @@
+export class PsSwipeActionService {
+    static tone(item) {
+        if (item.tone !== undefined)
+            return item.tone;
+        return item.isDanger === true ? 'danger' : 'primary';
+    }
+    static background(item, theme) {
+        const tone = PsSwipeActionService.tone(item);
+        if (tone === 'danger')
+            return theme.danger;
+        if (tone === 'success')
+            return theme.success;
+        if (tone === 'accent')
+            return theme.accent;
+        return theme.primary;
+    }
+    static foreground(item, theme) {
+        return PsSwipeActionService.tone(item) === 'primary' ? theme.primaryContrast : theme.white;
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare class PsSwipeService {
+    static clamp(x: number, hasLeading: boolean, hasTrailing: boolean, width: number): number;
+    static isArmed(x: number, width: number): boolean;
+    static shouldCommit(x: number, velocityX: number, width: number): boolean;
+    static progress(x: number, width: number): number;
+}

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

@@ -0,0 +1,27 @@
+import { PsSwipeConfig } from '../constants/ps-swipe-config';
+export class PsSwipeService {
+    static clamp(x, hasLeading, hasTrailing, width) {
+        if ((x > 0 && !hasLeading) || (x < 0 && !hasTrailing) || width === 0)
+            return 0;
+        const limit = width * PsSwipeConfig.maxFraction;
+        const distance = Math.abs(x);
+        if (distance <= limit)
+            return x;
+        return Math.sign(x) * (limit + (distance - limit) * PsSwipeConfig.rubberBand);
+    }
+    static isArmed(x, width) {
+        return width > 0 && Math.abs(x) >= width * PsSwipeConfig.commitFraction;
+    }
+    static shouldCommit(x, velocityX, width) {
+        if (PsSwipeService.isArmed(x, width))
+            return true;
+        return (Math.abs(velocityX) >= PsSwipeConfig.flingVelocity &&
+            Math.sign(velocityX) === Math.sign(x) &&
+            Math.abs(x) >= width * PsSwipeConfig.flingFraction);
+    }
+    static progress(x, width) {
+        if (width === 0)
+            return 0;
+        return Math.min(1, Math.abs(x) / (width * PsSwipeConfig.commitFraction));
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { PsTabFrame } from '../interfaces/ps-tab-frame';
+export declare class PsTabsService {
+    static scrollTarget(frame: PsTabFrame | undefined, viewportWidth: number): number | null;
+}

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

@@ -0,0 +1,8 @@
+import { PsTabsConfig } from '../constants/ps-tabs-config';
+export class PsTabsService {
+    static scrollTarget(frame, viewportWidth) {
+        if (frame === undefined || viewportWidth === 0)
+            return null;
+        return Math.max(0, frame.x - (viewportWidth - frame.width) / 2 - PsTabsConfig.scrollMargin / 2);
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { TextStyle } from 'react-native';
+import type { PsFontWeight } from '../interfaces/ps-font-weight';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+import type { PsTextTone } from '../interfaces/ps-text-tone';
+import type { PsTextVariant } from '../interfaces/ps-text-variant';
+export declare class PsTextService {
+    static color(tone: PsTextTone, theme: PsMobileTheme): string;
+    static style(variant: PsTextVariant, tone: PsTextTone, weight: PsFontWeight | undefined, theme: PsMobileTheme): TextStyle;
+}

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

@@ -0,0 +1,31 @@
+import { PsTextConfig } from '../constants/ps-text-config';
+export class PsTextService {
+    static color(tone, theme) {
+        switch (tone) {
+            case 'danger':
+                return theme.danger;
+            case 'muted':
+                return theme.muted;
+            case 'primary':
+                return theme.primary;
+            case 'success':
+                return theme.success;
+            case 'warning':
+                return theme.warning;
+            case 'white':
+                return theme.white;
+            default:
+                return theme.ink;
+        }
+    }
+    static style(variant, tone, weight, theme) {
+        const base = PsTextConfig[variant];
+        return {
+            color: PsTextService.color(tone, theme),
+            fontFamily: theme.fonts[weight === undefined ? base.weight : weight],
+            fontSize: base.fontSize,
+            fontVariant: variant === 'numeric' ? ['tabular-nums'] : undefined,
+            lineHeight: base.lineHeight,
+        };
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { PsHapticKind } from '../interfaces/ps-haptic-kind';
+import type { PsMobileTheme } from '../interfaces/ps-mobile-theme';
+import type { PsToastTone } from '../interfaces/ps-toast-tone';
+export declare class PsToastToneService {
+    static accent(theme: PsMobileTheme, tone: PsToastTone): string;
+    static haptic(tone: PsToastTone): PsHapticKind | null;
+    static duration(hasAction: boolean, durationMs: number, actionDurationMs: number): number;
+}

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

@@ -0,0 +1,26 @@
+export class PsToastToneService {
+    static accent(theme, tone) {
+        switch (tone) {
+            case 'danger':
+                return theme.danger;
+            case 'success':
+                return theme.success;
+            case 'warning':
+                return theme.warning;
+            case 'neutral':
+                return theme.muted;
+            default:
+                return theme.primary;
+        }
+    }
+    static haptic(tone) {
+        if (tone === 'danger')
+            return 'error';
+        if (tone === 'success')
+            return 'success';
+        return tone === 'warning' ? 'warning' : null;
+    }
+    static duration(hasAction, durationMs, actionDurationMs) {
+        return hasAction ? actionDurationMs : durationMs;
+    }
+}

package/jest-setup.js

@@ -0,0 +1,59 @@
+require('react-native-gesture-handler/jestSetup');
+
+jest.mock('react-native-reanimated', () => {
+	const { View } = require('react-native');
+	const isSharedValue = (value) => typeof value === 'object' && value !== null && 'value' in value;
+	const builder = { delay: () => builder, duration: () => builder, springify: () => builder };
+
+	return {
+		__esModule: true,
+		default: { View, createAnimatedComponent: (component) => component, isSharedValue },
+		isSharedValue,
+		FadeIn: builder,
+		FadeInDown: builder,
+		Easing: { linear: 'linear' },
+		cancelAnimation: () => undefined,
+		interpolate: (value, input, output) => output[0],
+		withRepeat: (value) => value,
+		FadeInUp: builder,
+		FadeOutUp: builder,
+		useAnimatedProps: (props) => props(),
+		useAnimatedStyle: (style) => style(),
+		useComposedEventHandler: () => () => undefined,
+		useReducedMotion: () => false,
+		useSharedValue: (initial) => {
+			const shared = {
+				value: initial,
+				get: () => shared.value,
+				set: (next) => {
+					shared.value = next;
+				},
+			};
+
+			return shared;
+		},
+		withDelay: (_delay, value) => value,
+		withSequence: (...values) => values[values.length - 1],
+		withTiming: (value) => value,
+	};
+});
+
+jest.mock('expo-haptics', () => ({
+	__esModule: true,
+	ImpactFeedbackStyle: { Heavy: 'heavy', Light: 'light', Medium: 'medium' },
+	NotificationFeedbackType: { Error: 'error', Success: 'success', Warning: 'warning' },
+	impactAsync: jest.fn(() => Promise.resolve()),
+	notificationAsync: jest.fn(() => Promise.resolve()),
+	selectionAsync: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock('@react-native-menu/menu', () => {
+	const React = require('react');
+	const { View } = require('react-native');
+
+	return {
+		__esModule: true,
+		MenuView: ({ actions, children, onPressAction, testID }) =>
+			React.createElement(View, { actions, onPressAction, testID }, children),
+	};
+});

package/package.json

@@ -1,6 +1,116 @@
 {
-  "name": "@pallasoft/ps-mobile-components",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@pallasoft/ps-mobile-components",
+	"version": "1.0.0",
+	"private": false,
+	"description": "Native iOS (SwiftUI) and Android (Jetpack Compose) Ps components for Pallasoft mobile apps",
+	"main": "./dist/index.js",
+	"react-native": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"sideEffects": false,
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"react-native": "./dist/index.js",
+			"require": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./jest-setup": "./jest-setup.js"
+	},
+	"files": [
+		"/dist",
+		"/jest-setup.js"
+	],
+	"scripts": {
+		"husky:prepare": "npx husky",
+		"build": "tsc",
+		"typecheck": "tsc --noEmit -p tsconfig.typecheck.json",
+		"lint": "npm run lint:eslint",
+		"lint:fix": "npm run lint:eslint:fix",
+		"format:check": "npx prettier --check --ignore-unknown \"src/**/*.{ts,tsx,json,md}\"",
+		"format:prettier": "npx prettier --write \"src/**/*.{ts,tsx,json,md}\"",
+		"lint:eslint": "npx eslint \"src/**/*.{ts,tsx}\"",
+		"lint:eslint:fix": "npx eslint --fix \"src/**/*.{ts,tsx}\"",
+		"release": "semantic-release",
+		"test": "jest"
+	},
+	"dependencies": {
+		"@pallasoft/ps-design-system": "^1.17.0",
+		"@pallasoft/ps-icons": "^1.11.0",
+		"@pallasoft/ps-utilities": "^2.26.0"
+	},
+	"peerDependencies": {
+		"@expo/ui": "~58.0.0",
+		"@react-native-menu/menu": "^2.0.0",
+		"expo": "~58.0.0",
+		"expo-haptics": "~58.0.7",
+		"expo-linear-gradient": "~58.0.3",
+		"react": "^19.3.0",
+		"react-native": "~0.88.0",
+		"react-native-document-scanner-plugin": "^2.0.4",
+		"react-native-gesture-handler": "~3.3.0",
+		"react-native-reanimated": "~4.7.1",
+		"react-native-safe-area-context": "~5.10.1",
+		"react-native-svg": "~15.16.0"
+	},
+	"peerDependenciesMeta": {
+		"react-native-document-scanner-plugin": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@babel/core": "^7.28.0",
+		"@commitlint/cli": "^20.1.0",
+		"@commitlint/config-conventional": "^20.0.0",
+		"@eslint/compat": "^2.0.0",
+		"@eslint/eslintrc": "^3.3.1",
+		"@eslint/js": "^9.39.1",
+		"@expo/ui": "~58.0.21",
+		"@ianvs/prettier-plugin-sort-imports": "^4.7.0",
+		"@react-native-menu/menu": "^2.0.0",
+		"@semantic-release/changelog": "^6.0.3",
+		"@semantic-release/commit-analyzer": "^13.0.0",
+		"@semantic-release/git": "^10.0.1",
+		"@semantic-release/github": "^11.0.1",
+		"@semantic-release/npm": "^12.0.0",
+		"@semantic-release/release-notes-generator": "^14.0.1",
+		"@testing-library/react-native": "^13.3.3",
+		"@types/jest": "^30.0.0",
+		"@types/react": "^19.3.0",
+		"@typescript-eslint/eslint-plugin": "^8.48.0",
+		"@typescript-eslint/parser": "^8.48.0",
+		"babel-preset-expo": "~58.0.0",
+		"commitlint": "^20.1.0",
+		"conventional-changelog-conventionalcommits": "^7.0.2",
+		"eslint": "^9.39.1",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-import": "^2.32.0",
+		"eslint-plugin-prettier": "^5.5.4",
+		"expo": "~58.0.16",
+		"expo-haptics": "~58.0.7",
+		"expo-linear-gradient": "~58.0.3",
+		"husky": "^9.1.7",
+		"jest": "^30.5.2",
+		"jest-expo": "~58.0.11",
+		"lint-staged": "^16.2.7",
+		"prettier": "^3.6.2",
+		"react": "^19.3.1",
+		"react-native": "0.88.0",
+		"react-native-gesture-handler": "~3.3.0",
+		"react-native-reanimated": "^4.7.1",
+		"react-native-safe-area-context": "~5.10.1",
+		"react-native-svg": "^15.16.0",
+		"react-native-worklets": "^0.13.0",
+		"react-test-renderer": "^19.3.1",
+		"semantic-release": "^24.2.0",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.9.3"
+	},
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org/"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/pallasoft/ps-mobile-components.git"
+	}
+}