nastech-app 1.0.0

package/sources/utils/pasteImages.web.ts

@@ -0,0 +1,81 @@
+/**
+ * Extract image files from a ClipboardEvent or DragEvent on web.
+ * Returns File objects that can be read and added as AttachmentPreview items.
+ */
+
+export function getImagesFromClipboard(event: ClipboardEvent): File[] {
+    const items = event.clipboardData?.items;
+    if (!items) return [];
+
+    const images: File[] = [];
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (item.kind === 'file' && item.type.startsWith('image/')) {
+            const file = item.getAsFile();
+            if (file) images.push(file);
+        }
+    }
+    return images;
+}
+
+export function getImagesFromDrop(event: DragEvent): File[] {
+    const files = event.dataTransfer?.files;
+    if (!files) return [];
+
+    const images: File[] = [];
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        if (file.type.startsWith('image/')) {
+            images.push(file);
+        }
+    }
+    return images;
+}
+
+export async function fileToAttachmentPreview(
+    file: File,
+    generateThumbhash: (uri: string, w: number, h: number) => Promise<string | undefined>,
+): Promise<{
+    uri: string;
+    width: number;
+    height: number;
+    size: number;
+    name: string;
+    mimeType: string;
+    thumbhash?: string;
+} | null> {
+    try {
+        const uri = URL.createObjectURL(file);
+
+        // Get dimensions by loading as an Image element
+        const { width, height } = await new Promise<{ width: number; height: number }>((resolve, reject) => {
+            const img = new Image();
+            const timeout = setTimeout(() => reject(new Error('timeout')), 5000);
+            img.onload = () => {
+                clearTimeout(timeout);
+                resolve({ width: img.naturalWidth, height: img.naturalHeight });
+            };
+            img.onerror = () => {
+                clearTimeout(timeout);
+                reject(new Error('load error'));
+            };
+            img.src = uri;
+        });
+
+        const thumbhash = (width > 0 && height > 0)
+            ? await generateThumbhash(uri, width, height)
+            : undefined;
+
+        return {
+            uri,
+            width,
+            height,
+            size: file.size,
+            name: file.name || `paste_${Date.now()}.png`,
+            mimeType: file.type || 'image/png',
+            thumbhash,
+        };
+    } catch {
+        return null;
+    }
+}

package/sources/utils/pathUtils.spec.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect } from 'vitest';
+import { resolveAbsolutePath, resolvePath } from './pathUtils';
+
+describe('pathUtils', () => {
+    describe('resolveAbsolutePath', () => {
+        describe('basic tilde expansion', () => {
+            it('should expand ~ to home directory', () => {
+                expect(resolveAbsolutePath('~', '/Users/steve')).toBe('/Users/steve');
+            });
+
+            it('should expand ~/ to home directory with trailing slash', () => {
+                expect(resolveAbsolutePath('~/', '/Users/steve')).toBe('/Users/steve/');
+            });
+
+            it('should expand ~/Documents to home directory plus path', () => {
+                expect(resolveAbsolutePath('~/Documents', '/Users/steve')).toBe('/Users/steve/Documents');
+            });
+
+            it('should expand ~/Documents/project to nested path', () => {
+                expect(resolveAbsolutePath('~/Documents/project', '/Users/steve')).toBe('/Users/steve/Documents/project');
+            });
+
+            it('should expand ~/Documents/deep/nested/path', () => {
+                expect(resolveAbsolutePath('~/Documents/deep/nested/path', '/Users/steve')).toBe('/Users/steve/Documents/deep/nested/path');
+            });
+        });
+
+        describe('non-tilde paths remain unchanged', () => {
+            it('should not modify absolute Unix paths', () => {
+                expect(resolveAbsolutePath('/usr/local/bin', '/Users/steve')).toBe('/usr/local/bin');
+            });
+
+            it('should not modify absolute Windows paths', () => {
+                expect(resolveAbsolutePath('C:\\Program Files', 'C:\\Users\\steve')).toBe('C:\\Program Files');
+            });
+
+            it('should not modify relative paths', () => {
+                expect(resolveAbsolutePath('./folder', '/Users/steve')).toBe('./folder');
+                expect(resolveAbsolutePath('../parent', '/Users/steve')).toBe('../parent');
+                expect(resolveAbsolutePath('relative/path', '/Users/steve')).toBe('relative/path');
+            });
+
+            it('should not modify paths starting with ~username (other user homes)', () => {
+                expect(resolveAbsolutePath('~root', '/Users/steve')).toBe('~root');
+                expect(resolveAbsolutePath('~john/Documents', '/Users/steve')).toBe('~john/Documents');
+            });
+        });
+
+        describe('Windows path handling', () => {
+            it('should expand ~ with Windows home directory', () => {
+                expect(resolveAbsolutePath('~', 'C:\\Users\\steve')).toBe('C:\\Users\\steve');
+            });
+
+            it('should use Windows separator for Windows home', () => {
+                expect(resolveAbsolutePath('~/Documents', 'C:\\Users\\steve')).toBe('C:\\Users\\steve\\Documents');
+                expect(resolveAbsolutePath('~/Documents/project', 'C:\\Users\\steve')).toBe('C:\\Users\\steve\\Documents/project');
+            });
+
+            it('should handle Windows home with forward slashes', () => {
+                expect(resolveAbsolutePath('~/Documents', 'C:/Users/steve')).toBe('C:/Users/steve/Documents');
+            });
+        });
+
+        describe('edge cases', () => {
+            it('should return original path when homeDir is undefined', () => {
+                expect(resolveAbsolutePath('~', undefined)).toBe('~');
+                expect(resolveAbsolutePath('~/Documents', undefined)).toBe('~/Documents');
+            });
+
+            it('should return original path when homeDir is empty', () => {
+                expect(resolveAbsolutePath('~', '')).toBe('~');
+                expect(resolveAbsolutePath('~/Documents', '')).toBe('~/Documents');
+            });
+
+            it('should handle homeDir with trailing separator', () => {
+                expect(resolveAbsolutePath('~', '/Users/steve/')).toBe('/Users/steve');
+                expect(resolveAbsolutePath('~/Documents', '/Users/steve/')).toBe('/Users/steve/Documents');
+                expect(resolveAbsolutePath('~', 'C:\\Users\\steve\\')).toBe('C:\\Users\\steve');
+                expect(resolveAbsolutePath('~/Documents', 'C:\\Users\\steve\\')).toBe('C:\\Users\\steve\\Documents');
+            });
+
+            it('should handle empty string path', () => {
+                expect(resolveAbsolutePath('', '/Users/steve')).toBe('');
+            });
+
+            it('should handle paths with spaces', () => {
+                expect(resolveAbsolutePath('~/My Documents', '/Users/steve')).toBe('/Users/steve/My Documents');
+                expect(resolveAbsolutePath('~/Program Files/My App', 'C:\\Users\\steve')).toBe('C:\\Users\\steve\\Program Files/My App');
+            });
+
+            it('should handle paths with special characters', () => {
+                expect(resolveAbsolutePath('~/Documents & Files', '/Users/steve')).toBe('/Users/steve/Documents & Files');
+                expect(resolveAbsolutePath('~/folder@example.com', '/Users/steve')).toBe('/Users/steve/folder@example.com');
+            });
+        });
+
+        describe('path separator normalization', () => {
+            it('should use Unix separator for Unix home paths', () => {
+                expect(resolveAbsolutePath('~/Documents/subfolder', '/home/user')).toBe('/home/user/Documents/subfolder');
+                expect(resolveAbsolutePath('~/Documents/subfolder', '/Users/steve')).toBe('/Users/steve/Documents/subfolder');
+            });
+
+            it('should use Windows separator for Windows home paths', () => {
+                expect(resolveAbsolutePath('~/Documents/subfolder', 'C:\\Users\\steve')).toBe('C:\\Users\\steve\\Documents/subfolder');
+            });
+
+            it('should handle mixed separators in home directory', () => {
+                // Edge case: mixed separators in homeDir - should use the last separator type found
+                expect(resolveAbsolutePath('~/Documents', 'C:/Users\\steve')).toBe('C:/Users\\steve\\Documents');
+            });
+        });
+
+        describe('long paths', () => {
+            it('should handle very long paths', () => {
+                const longPath = '~/Documents/' + 'a'.repeat(200) + '/file.txt';
+                const result = resolveAbsolutePath(longPath, '/Users/steve');
+                expect(result).toBe('/Users/steve/Documents/' + 'a'.repeat(200) + '/file.txt');
+            });
+
+            it('should handle very long home directory paths', () => {
+                const longHome = '/very/long/path/to/users/' + 'b'.repeat(100) + '/steve';
+                expect(resolveAbsolutePath('~/Documents', longHome)).toBe(longHome + '/Documents');
+            });
+        });
+    });
+
+    describe('resolvePath (existing function)', () => {
+        it('should return original path when metadata is null', () => {
+            expect(resolvePath('/some/path', null)).toBe('/some/path');
+        });
+
+        it('should resolve path relative to metadata root', () => {
+            const metadata = {
+                path: '/Users/steve/project',
+                host: 'localhost',
+                homeDir: '/Users/steve'
+            };
+            expect(resolvePath('/Users/steve/project/src/file.ts', metadata)).toBe('src/file.ts');
+        });
+
+        it('should return <root> for exact metadata path', () => {
+            const metadata = {
+                path: '/Users/steve/project',
+                host: 'localhost',
+                homeDir: '/Users/steve'
+            };
+            expect(resolvePath('/Users/steve/project', metadata)).toBe('<root>');
+        });
+
+        it('should handle case insensitive matching', () => {
+            const metadata = {
+                path: '/Users/Steve/Project',
+                host: 'localhost',
+                homeDir: '/Users/Steve'
+            };
+            expect(resolvePath('/users/steve/project/src/file.ts', metadata)).toBe('src/file.ts');
+        });
+
+        it('should return original path if not under metadata path', () => {
+            const metadata = {
+                path: '/Users/steve/project',
+                host: 'localhost',
+                homeDir: '/Users/steve'
+            };
+            expect(resolvePath('/usr/local/bin/node', metadata)).toBe('/usr/local/bin/node');
+        });
+
+        it('should not resolve sibling directory paths that start with metadata path', () => {
+            const metadata = {
+                path: '/Users/steve/Develop/nastech-ai/nastech',
+                host: 'localhost',
+                homeDir: '/Users/steve'
+            };
+            // This should NOT be resolved as it's a sibling directory, not within the metadata path
+            expect(resolvePath('/Users/steve/Develop/nastech-ai/nastech-server/sources/types/index.ts', metadata))
+                .toBe('/Users/steve/Develop/nastech-ai/nastech-server/sources/types/index.ts');
+        });
+
+        it('should handle edge case where metadata path is a substring of another path', () => {
+            const metadata = {
+                path: '/home/user/app',
+                host: 'localhost',
+                homeDir: '/home/user'
+            };
+            // These should NOT be resolved
+            expect(resolvePath('/home/user/app-v2/src/main.js', metadata))
+                .toBe('/home/user/app-v2/src/main.js');
+            expect(resolvePath('/home/user/application/config.json', metadata))
+                .toBe('/home/user/application/config.json');
+        });
+    });
+
+    describe('integration scenarios', () => {
+        it('should work with typical macOS home directories', () => {
+            const homeDir = '/Users/developer';
+            expect(resolveAbsolutePath('~', homeDir)).toBe('/Users/developer');
+            expect(resolveAbsolutePath('~/Projects/nastech', homeDir)).toBe('/Users/developer/Projects/nastech');
+            expect(resolveAbsolutePath('~/Desktop/file.txt', homeDir)).toBe('/Users/developer/Desktop/file.txt');
+        });
+
+        it('should work with typical Linux home directories', () => {
+            const homeDir = '/home/developer';
+            expect(resolveAbsolutePath('~', homeDir)).toBe('/home/developer');
+            expect(resolveAbsolutePath('~/projects/nastech', homeDir)).toBe('/home/developer/projects/nastech');
+            expect(resolveAbsolutePath('~/documents/file.txt', homeDir)).toBe('/home/developer/documents/file.txt');
+        });
+
+        it('should work with typical Windows home directories', () => {
+            const homeDir = 'C:\\Users\\developer';
+            expect(resolveAbsolutePath('~', homeDir)).toBe('C:\\Users\\developer');
+            expect(resolveAbsolutePath('~/Projects/nastech', homeDir)).toBe('C:\Users\developer\Projects/nastech');
+            expect(resolveAbsolutePath('~/Desktop/file.txt', homeDir)).toBe('C:\\Users\\developer\\Desktop/file.txt');
+        });
+
+        it('should handle common session creation scenarios', () => {
+            // Scenarios that would commonly occur in new-session.tsx
+            const macHomeDir = '/Users/steve';
+            
+            expect(resolveAbsolutePath('~', macHomeDir)).toBe('/Users/steve');
+            expect(resolveAbsolutePath('~/Code', macHomeDir)).toBe('/Users/steve/Code');
+            expect(resolveAbsolutePath('~/Documents/Projects', macHomeDir)).toBe('/Users/steve/Documents/Projects');
+            expect(resolveAbsolutePath('/absolute/path', macHomeDir)).toBe('/absolute/path');
+            expect(resolveAbsolutePath('./relative', macHomeDir)).toBe('./relative');
+        });
+    });
+});

package/sources/utils/pathUtils.ts

@@ -0,0 +1,75 @@
+import { Metadata } from '@/sync/storageTypes';
+
+/**
+ * Resolves a path relative to the root path from metadata.
+ * ALL paths are treated as relative to the metadata root, regardless of their format.
+ * If metadata is not provided, returns the original path.
+ * 
+ * @param path - The path to resolve (always treated as relative to the metadata root)
+ * @param metadata - Optional metadata containing the root path
+ * @returns The resolved absolute path
+ */
+export function resolvePath(path: string, metadata: Metadata | null): string {
+    if (!metadata) {
+        return path;
+    }
+    if (path.toLowerCase().startsWith(metadata.path.toLowerCase())) {
+        // Check that the path is actually within the metadata path by ensuring
+        // there's either an exact match or a path separator after the metadata path
+        const remainder = path.slice(metadata.path.length);
+        if (remainder === '' || remainder.startsWith('/')) {
+            let out = remainder;
+            if (out.startsWith('/')) {
+                out = out.slice(1);
+            }
+            if (out === '') {
+                return '<root>';
+            }
+            return out;
+        }
+    }
+    return path;
+}
+
+/**
+ * Resolves paths starting with ~ to absolute paths using the provided home directory.
+ * Non-tilde paths are returned unchanged.
+ * 
+ * @param path - The path to resolve (may start with ~)
+ * @param homeDir - The user's home directory (e.g., '/Users/steve' or 'C:\Users\steve')
+ * @returns The resolved absolute path
+ */
+export function resolveAbsolutePath(path: string, homeDir?: string): string {
+    // Return original path if it doesn't start with ~
+    if (!path.startsWith('~')) {
+        return path;
+    }
+    
+    // Return original path if no home directory provided
+    if (!homeDir) {
+        return path;
+    }
+    
+    // Handle exact ~ (home directory)
+    if (path === '~') {
+        // Remove trailing separator for consistency
+        return homeDir.endsWith('/') || homeDir.endsWith('\\') 
+            ? homeDir.slice(0, -1) 
+            : homeDir;
+    }
+    
+    // Handle ~/ and ~/path (home directory with subdirectory)
+    if (path.startsWith('~/')) {
+        const relativePart = path.slice(2); // Remove '~/'
+        // Detect path separator based on homeDir - prefer the last separator found
+        const hasBackslash = homeDir.lastIndexOf('\\') > homeDir.lastIndexOf('/');
+        const separator = hasBackslash ? '\\' : '/';
+        const normalizedHome = homeDir.endsWith('/') || homeDir.endsWith('\\') 
+            ? homeDir.slice(0, -1) 
+            : homeDir;
+        return normalizedHome + separator + relativePart;
+    }
+    
+    // Handle ~username paths (not supported, return original)
+    return path;
+}

package/sources/utils/platform.ts

@@ -0,0 +1,19 @@
+import { Platform } from 'react-native';
+import { getDeviceType } from 'react-native-device-info';
+
+const deviceType = getDeviceType();
+
+export function isRunningOnMac(): boolean {
+    if (Platform.OS !== 'ios') {
+        return false;
+    }
+    
+    if (deviceType === 'Desktop') {
+        return true;
+    }
+    
+    // Check if running on Mac Catalyst
+    // @ts-ignore - isPad is not in the type definitions but exists at runtime
+    return Platform.isPad && Platform.Version && typeof Platform.Version === 'string' && 
+           Platform.Version.includes('Mac');
+}

package/sources/utils/readFileBytes.ts

@@ -0,0 +1,11 @@
+/**
+ * Read file bytes from a URI — native implementation.
+ * Uses expo-file-system/legacy to read file:// URIs on iOS/Android.
+ */
+import { readAsStringAsync, EncodingType } from 'expo-file-system/legacy';
+import { decodeBase64 } from '@/encryption/base64';
+
+export async function readFileBytes(uri: string): Promise<Uint8Array> {
+    const base64 = await readAsStringAsync(uri, { encoding: EncodingType.Base64 });
+    return decodeBase64(base64);
+}

package/sources/utils/readFileBytes.web.ts

@@ -0,0 +1,12 @@
+/**
+ * Read file bytes from a URI — web implementation.
+ * Uses fetch() on blob: and data: URIs returned by expo-image-picker on web.
+ */
+export async function readFileBytes(uri: string): Promise<Uint8Array> {
+    const response = await fetch(uri);
+    if (!response.ok) {
+        throw new Error(`readFileBytes: fetch failed with status ${response.status}`);
+    }
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+}

package/sources/utils/requestReview.ts

@@ -0,0 +1,135 @@
+import * as StoreReview from 'expo-store-review';
+import { MMKV } from 'react-native-mmkv';
+import { Modal } from '@/modal';
+import { t } from '@/text';
+import { AsyncLock } from './lock';
+import {
+    trackReviewPromptShown,
+    trackReviewPromptResponse,
+    trackReviewStoreShown,
+    trackReviewRetryScheduled
+} from '@/track';
+import { sync } from '@/sync/sync';
+import { storage as syncStorage } from '@/sync/storage';
+import { Platform } from 'react-native';
+
+const localStorage = new MMKV();
+
+const LOCAL_KEYS = {
+    STORE_REVIEW_LAST_SHOWN: 'review_store_last_shown',
+    DECLINED_AT: 'review_declined_at',
+} as const;
+
+const RETRY_DAYS = 30;
+const STORE_REVIEW_RETRY_DAYS = 7; // Allow store review again after a week
+const DAY_IN_MS = 24 * 60 * 60 * 1000;
+const lock = new AsyncLock();
+
+export function requestReview() {
+    if (Platform.OS === 'web') {
+        return;
+    }
+
+    lock.inLock(async () => {
+        try {
+
+            // Check if store review is available
+            const isAvailable = await StoreReview.isAvailableAsync();
+            if (!isAvailable) {
+                console.log('Store review is not available on this platform');
+                return;
+            }
+
+            const settings = syncStorage.getState().settings;
+
+            // Check if we should show store review directly (user already answered and liked the app)
+            if (settings.reviewPromptAnswered && settings.reviewPromptLikedApp) {
+                // Check if enough time has passed since last store review
+                const lastShownStr = localStorage.getString(LOCAL_KEYS.STORE_REVIEW_LAST_SHOWN);
+                if (lastShownStr) {
+                    const lastShown = new Date(lastShownStr);
+                    const now = new Date();
+                    const daysSinceShown = (now.getTime() - lastShown.getTime()) / DAY_IN_MS;
+
+                    if (daysSinceShown < STORE_REVIEW_RETRY_DAYS) {
+                        // Not enough time has passed since last store review
+                        return;
+                    }
+                }
+
+                await StoreReview.requestReview();
+                trackReviewStoreShown();
+                localStorage.set(LOCAL_KEYS.STORE_REVIEW_LAST_SHOWN, new Date().toISOString());
+                return;
+            }
+
+            // Check if user already answered the prompt (synced across devices)
+            if (settings.reviewPromptAnswered) {
+                // User already answered on another device, don't ask again
+                return;
+            }
+
+            // Check if user previously declined and if it's been 30 days (local check)
+            const declinedAtStr = localStorage.getString(LOCAL_KEYS.DECLINED_AT);
+            if (declinedAtStr) {
+                const declinedAt = new Date(declinedAtStr);
+                const now = new Date();
+                const daysSinceDeclined = (now.getTime() - declinedAt.getTime()) / DAY_IN_MS;
+
+                if (daysSinceDeclined < RETRY_DAYS) {
+                    // Not enough time has passed since last decline
+                    return;
+                }
+            }
+
+            // Pre-ask if they like the app (only shown once, ever)
+            trackReviewPromptShown();
+            const likesApp = await Modal.confirm(
+                t('review.enjoyingApp'),
+                t('review.feedbackPrompt'),
+                {
+                    confirmText: t('review.yesILoveIt'),
+                    cancelText: t('review.notReally'),
+                }
+            );
+            trackReviewPromptResponse(likesApp);
+
+            // Store the answer in sync settings (synced across devices)
+            sync.applySettings({
+                reviewPromptAnswered: true,
+                reviewPromptLikedApp: likesApp,
+            });
+
+            if (!likesApp) {
+                // User doesn't like the app, store the timestamp locally
+                localStorage.set(LOCAL_KEYS.DECLINED_AT, new Date().toISOString());
+
+                // Track that we'll retry in 30 days
+                trackReviewRetryScheduled(RETRY_DAYS);
+                return;
+            }
+
+            // Request the actual store review directly
+            await StoreReview.requestReview();
+            trackReviewStoreShown();
+
+            // Mark when we last showed the store review
+            localStorage.set(LOCAL_KEYS.STORE_REVIEW_LAST_SHOWN, new Date().toISOString());
+
+        } catch (error) {
+            console.error('Error requesting review:', error);
+        }
+    });
+}
+
+// Optional: Reset review state for testing
+export function resetReviewState(): void {
+    localStorage.delete(LOCAL_KEYS.DECLINED_AT);
+    localStorage.delete(LOCAL_KEYS.STORE_REVIEW_LAST_SHOWN);
+
+    // Reset sync settings
+    sync.applySettings({
+        reviewPromptAnswered: false,
+        reviewPromptLikedApp: null,
+    });
+}

package/sources/utils/responsive.ts

@@ -0,0 +1,87 @@
+import { Dimensions, Platform } from 'react-native';
+import { useWindowDimensions } from 'react-native';
+import { useMemo } from 'react';
+import { calculateDeviceDimensions, determineDeviceType, calculateHeaderHeight } from './deviceCalculations';
+import { isRunningOnMac } from './platform';
+
+// Re-export calculation functions for use in other components
+export { calculateDeviceDimensions, determineDeviceType, calculateHeaderHeight };
+
+// Get header height based on platform, device type, and orientation (wrapper for backward compatibility)
+export function getHeaderHeight(isLandscape: boolean, deviceType: 'phone' | 'tablet'): number {
+    return calculateHeaderHeight({
+        platform: Platform.OS,
+        isLandscape,
+        // @ts-ignore - isPad is not in the type definitions but exists at runtime on iOS
+        isPad: Platform.OS === 'ios' ? Platform.isPad : undefined,
+        deviceType: Platform.OS === 'android' ? deviceType : undefined,
+        isMacCatalyst: isRunningOnMac()
+    });
+}
+
+// Device type detection based on screen size and aspect ratio
+export function getDeviceType(): 'phone' | 'tablet' {
+    const { width, height } = Dimensions.get('screen');
+
+    const dimensions = calculateDeviceDimensions({
+        widthPoints: width,
+        heightPoints: height,
+        pointsPerInch: Platform.OS === 'ios' ? 163 : 160
+    });
+
+    return determineDeviceType({
+        diagonalInches: dimensions.diagonalInches,
+        platform: Platform.OS,
+        // @ts-ignore - isPad is not in the type definitions but exists at runtime on iOS
+        isPad: Platform.OS === 'ios' ? Platform.isPad : false
+    });
+}
+
+// Hook to get device type (reactive to dimension changes)
+export function useDeviceType(): 'phone' | 'tablet' {
+    const { width, height } = useWindowDimensions();
+    
+    return useMemo(() => {
+        const dimensions = calculateDeviceDimensions({
+            widthPoints: width,
+            heightPoints: height,
+            pointsPerInch: Platform.OS === 'ios' ? 163 : 160
+        });
+
+        return determineDeviceType({
+            diagonalInches: dimensions.diagonalInches,
+            platform: Platform.OS,
+            // @ts-ignore - isPad is not in the type definitions but exists at runtime on iOS
+            isPad: Platform.OS === 'ios' ? Platform.isPad : false
+        });
+    }, [width, height]);
+}
+
+// Hook to detect if device is tablet
+export function useIsTablet(): boolean {
+    const deviceType = useDeviceType();
+    return deviceType === 'tablet';
+}
+
+// Hook to detect landscape orientation
+export function useIsLandscape(): boolean {
+    const { width, height } = useWindowDimensions();
+    return width > height;
+}
+
+// Hook to get header height based on platform, device type, and orientation
+export function useHeaderHeight(): number {
+    const isLandscape = useIsLandscape();
+    const deviceType = useDeviceType();
+    
+    return useMemo(() => {
+        return calculateHeaderHeight({
+            platform: Platform.OS,
+            isLandscape,
+            // @ts-ignore - isPad is not in the type definitions but exists at runtime on iOS
+            isPad: Platform.OS === 'ios' ? Platform.isPad : undefined,
+            deviceType: Platform.OS === 'android' ? deviceType : undefined,
+            isMacCatalyst: isRunningOnMac()
+        });
+    }, [isLandscape, deviceType]);
+}