@octane-xplat/platform 0.1.0 → 0.4.0

package/src/files.native.ts

@@ -1,24 +1,130 @@
-// Files — native leaf. FileRef wraps a real filesystem path under the app's
-// documents folder; picking delegates to the imagepicker/file picker seam.
-import { File, knownFolders, path } from '@nativescript/core';
-import type { FileRef } from './types';
+// Files — native leaf. FileRef wraps an opaque native URI. App-document paths
+// are still used for writes; picked Android SAF references may be content://
+// URIs and must be read through ContentResolver.
+import { openFilePicker } from '@nativescript-community/ui-document-picker'
+import { Application, File, knownFolders, path } from '@nativescript/core'
+import type { FileRef } from './types'
 
-const docs = () => knownFolders.documents();
+const docs = () => knownFolders.documents()
+
+function pickerTypes(accept: string): { extensions: string[]; mimeTypes: string[] } {
+	const values = accept
+		.split(',')
+		.map((value) => value.trim())
+		.filter(Boolean)
+
+	return {
+		extensions: values
+			.filter((value) => value.startsWith('.'))
+			.map((value) => value.slice(1)),
+		// `*/*` is the default, not a useful iOS UTType MIME value. Leaving it
+		// out lets the upstream picker use its public.data fallback.
+		mimeTypes: values.filter((value) => value.includes('/') && value !== '*/*'),
+	}
+}
+
+function androidDisplayName(uri: string, nativeUri: any): string | undefined {
+	if (!Application.android || !uri.startsWith('content://')) {
+		return undefined
+	}
+
+	try {
+		const activity = Application.android.foregroundActivity ?? Application.android.startActivity
+		const cursor = activity
+			?.getContentResolver()
+			?.query(nativeUri ?? android.net.Uri.parse(uri), null, null, null, null)
+
+		if (!cursor) {
+			return undefined
+		}
+
+		try {
+			if (!cursor.moveToFirst()) {
+				return undefined
+			}
+
+			const index = cursor.getColumnIndex('display_name')
+			return index >= 0 ? cursor.getString(index) : undefined
+		} finally {
+			cursor.close()
+		}
+	} catch {
+		return undefined
+	}
+}
+
+function fallbackName(uri: string): string {
+	const segment = uri.split('/').pop() ?? ''
+	try {
+		return decodeURIComponent(segment) || 'document'
+	} catch {
+		return segment || 'document'
+	}
+}
+
+async function readContentUri(uri: string): Promise<string> {
+	const activity = Application.android?.foregroundActivity ?? Application.android?.startActivity
+	const input = activity?.getContentResolver()?.openInputStream(android.net.Uri.parse(uri))
+
+	if (!input) {
+		throw new Error(`Unable to open picked file: ${uri}`)
+	}
+
+	const reader = new java.io.BufferedReader(new java.io.InputStreamReader(input))
+	const lines: string[] = []
+	try {
+		let line: string | null
+		while ((line = reader.readLine()) !== null) {
+			lines.push(line)
+		}
+
+		return lines.join('\n')
+	} finally {
+		reader.close()
+	}
+}
 
 export const files = {
-	/** Not implemented on native yet — file pickers are plugin-shaped;
-	 *  media.pickImage covers the common case. Returns null. */
-	async pick(_accept?: string): Promise<FileRef | null> {
-		return null;
+	/** Opens the platform document picker and returns its opaque native URI. */
+	async pick(accept = '*/*'): Promise<FileRef | null> {
+		const { extensions, mimeTypes } = pickerTypes(accept)
+		const result = await openFilePicker({
+			extensions,
+			mimeTypes,
+			multipleSelection: false,
+			permissions: { read: true, persistable: true },
+		})
+
+		const uri = result.files?.[0]
+
+		if (!uri) {
+			return null
+		}
+
+		const name = androidDisplayName(uri, result.android) ?? fallbackName(uri)
+		return { name, uri }
 	},
 	async readText(ref: FileRef): Promise<string> {
-		return File.fromPath(ref.uri).readText();
+		if (ref.uri.startsWith('content://')) {
+			return readContentUri(ref.uri)
+		}
+
+		return File.fromPath(ref.uri).readText()
 	},
 	async writeText(name: string, text: string): Promise<FileRef> {
-		const p = path.join(docs().path, name);
-		const f = File.fromPath(p);
-		f.writeTextSync(text);
-		return { name, uri: p };
+		const p = path.join(docs().path, name)
+		const f = File.fromPath(p)
+		f.writeTextSync(text)
+		return { name, uri: p }
+	},
+	release(ref: FileRef): void {
+		const cachePrefix = knownFolders.temp().path + '/'
+		if (!ref.uri.startsWith(cachePrefix)) {
+			return
+		}
+
+		try {
+			File.fromPath(ref.uri).removeSync()
+		} catch {}
 	},
-	release(_ref: FileRef): void {},
-};
+}

package/src/files.web.ts

@@ -1,34 +1,35 @@
 // Files — web leaf. Opaque FileRef: a blob/object URL plus a name; reads go
 // through FileReader/fetch on the ref's URL.
-import type { FileRef } from './types';
+import type { FileRef } from './types'
 
 export const files = {
 	async pick(accept = '*/*'): Promise<FileRef | null> {
 		return new Promise((resolve) => {
-			const input = document.createElement('input');
-			input.type = 'file';
-			input.accept = accept;
+			const input = document.createElement('input')
+			input.type = 'file'
+			input.accept = accept
 			input.onchange = () => {
-				const f = input.files?.[0];
-				resolve(f ? { name: f.name, uri: URL.createObjectURL(f) } : null);
-			};
-			input.oncancel = () => resolve(null);
-			input.click();
-		});
+				const f = input.files?.[0]
+				resolve(f ? { name: f.name, uri: URL.createObjectURL(f) } : null)
+			}
+
+			input.oncancel = () => resolve(null)
+			input.click()
+		})
 	},
 	async readText(ref: FileRef): Promise<string> {
-		return (await fetch(ref.uri)).text();
+		return (await fetch(ref.uri)).text()
 	},
 	/** "Write" on web = a download. Returns the object URL. */
 	async writeText(name: string, text: string): Promise<FileRef> {
-		const uri = URL.createObjectURL(new Blob([text], { type: 'text/plain' }));
-		const a = document.createElement('a');
-		a.href = uri;
-		a.download = name;
-		a.click();
-		return { name, uri };
+		const uri = URL.createObjectURL(new Blob([text], { type: 'text/plain' }))
+		const a = document.createElement('a')
+		a.href = uri
+		a.download = name
+		a.click()
+		return { name, uri }
 	},
 	release(ref: FileRef): void {
-		URL.revokeObjectURL(ref.uri);
+		URL.revokeObjectURL(ref.uri)
 	},
-};
+}

package/src/geolocation.native.ts

@@ -0,0 +1,44 @@
+// Geolocation — native leaf. The plugin's enableLocationRequest() owns the
+// runtime prompt; getCurrentLocation() is normalized to the web position shape.
+import * as geolocationApi from '@nativescript/geolocation'
+import { CoreTypes } from '@nativescript/core'
+import type { Capability, GeolocationImpl, GeolocationPosition } from './types'
+
+function asPosition(nativeLocation: any): GeolocationPosition {
+	return {
+		latitude: nativeLocation.latitude,
+		longitude: nativeLocation.longitude,
+		accuracy: nativeLocation.horizontalAccuracy ?? nativeLocation.accuracy ?? 0,
+		altitude: nativeLocation.altitude ?? null,
+		heading: nativeLocation.direction ?? nativeLocation.heading ?? null,
+		speed: nativeLocation.speed ?? null,
+		timestamp: Number(nativeLocation.timestamp ?? Date.now()),
+	}
+}
+
+const impl: GeolocationImpl = {
+	async getCurrentPosition(options) {
+		const nativePosition = await geolocationApi.getCurrentLocation({
+			desiredAccuracy: options?.enableHighAccuracy
+				? CoreTypes.Accuracy.high
+				: CoreTypes.Accuracy.any,
+			maximumAge: options?.maximumAge,
+			timeout: options?.timeout,
+		})
+
+		return asPosition(nativePosition)
+	},
+}
+
+export const geolocation: Capability<GeolocationImpl> = {
+	supported: true,
+	async ensure() {
+		try {
+			await geolocationApi.enableLocationRequest()
+			return 'granted'
+		} catch {
+			return 'denied'
+		}
+	},
+	impl,
+}

package/src/geolocation.web.ts

@@ -0,0 +1,50 @@
+// Geolocation — web leaf. The browser owns the permission prompt and returns
+// the platform-neutral position shape used by the service contract.
+import type { Capability, GeolocationImpl, GeolocationOptions, GeolocationPosition } from './types'
+
+const supported = typeof navigator !== 'undefined' && 'geolocation' in navigator
+
+function readPosition(options?: GeolocationOptions): Promise<GeolocationPosition> {
+	return new Promise((resolve, reject) => {
+		navigator.geolocation.getCurrentPosition(
+			(position) =>
+				resolve({
+					latitude: position.coords.latitude,
+					longitude: position.coords.longitude,
+					accuracy: position.coords.accuracy,
+					altitude: position.coords.altitude,
+					heading: position.coords.heading,
+					speed: position.coords.speed,
+					timestamp: position.timestamp,
+				}),
+			reject,
+			{
+				enableHighAccuracy: options?.enableHighAccuracy,
+				timeout: options?.timeout,
+				maximumAge: options?.maximumAge,
+			},
+		)
+	})
+}
+
+const impl: GeolocationImpl = {
+	getCurrentPosition: readPosition,
+}
+
+export const geolocation: Capability<GeolocationImpl> = {
+	supported,
+	async ensure() {
+		if (!supported) {
+			return 'unsupported'
+		}
+
+		try {
+			await readPosition({ timeout: 15000 })
+			return 'granted'
+		} catch (error) {
+			const code = (error as { code?: number }).code
+			return code === 1 ? 'denied' : 'unsupported'
+		}
+	},
+	impl,
+}

package/src/haptics.native.ts

@@ -1,7 +1,7 @@
 // Haptics — Taptic Engine (iOS) / Vibrator (Android) via @nativescript/haptics.
-import { Haptics, HapticImpactType, HapticNotificationType } from '@nativescript/haptics';
-import type { Capability } from './types';
-import type { HapticsImpl } from './types';
+import { Haptics, HapticImpactType, HapticNotificationType } from '@nativescript/haptics'
+import type { Capability } from './types'
+import type { HapticsImpl } from './types'
 
 export const haptics: Capability<HapticsImpl> = {
 	supported: true,
@@ -9,16 +9,20 @@ export const haptics: Capability<HapticsImpl> = {
 	impl: {
 		impact: (style = 'light') =>
 			Haptics.impact(
-				style === 'heavy' ? HapticImpactType.HEAVY
-				: style === 'medium' ? HapticImpactType.MEDIUM
-				: HapticImpactType.LIGHT,
+				style === 'heavy'
+					? HapticImpactType.HEAVY
+					: style === 'medium'
+						? HapticImpactType.MEDIUM
+						: HapticImpactType.LIGHT,
 			),
 		notification: (kind) =>
 			Haptics.notification(
-				kind === 'error' ? HapticNotificationType.ERROR
-				: kind === 'warning' ? HapticNotificationType.WARNING
-				: HapticNotificationType.SUCCESS,
+				kind === 'error'
+					? HapticNotificationType.ERROR
+					: kind === 'warning'
+						? HapticNotificationType.WARNING
+						: HapticNotificationType.SUCCESS,
 			),
 		selection: () => Haptics.selection(),
 	},
-};
+}

package/src/haptics.web.ts

@@ -1,16 +1,17 @@
 // Haptics — web leaf. navigator.vibrate exists on Android Chrome only;
 // iOS Safari and desktop report unsupported via the Capability contract.
-import type { Capability, HapticsImpl } from './types';
+import type { Capability, HapticsImpl } from './types'
 
 const vibrate = (ms: number | number[]) =>
-	typeof navigator !== 'undefined' && 'vibrate' in navigator && navigator.vibrate(ms);
+	typeof navigator !== 'undefined' && 'vibrate' in navigator && navigator.vibrate(ms)
 
 export const haptics: Capability<HapticsImpl> = {
 	supported: typeof navigator !== 'undefined' && 'vibrate' in navigator,
 	ensure: async () => ('vibrate' in navigator ? 'granted' : 'unsupported'),
 	impl: {
 		impact: (style) => vibrate(style === 'heavy' ? 30 : style === 'medium' ? 20 : 10),
-		notification: (kind) => vibrate(kind === 'error' ? [50, 60, 50] : kind === 'warning' ? [30, 40, 30] : 15),
+		notification: (kind) =>
+			vibrate(kind === 'error' ? [50, 60, 50] : kind === 'warning' ? [30, 40, 30] : 15),
 		selection: () => vibrate(5),
 	},
-};
+}

package/src/index.ts

@@ -3,25 +3,52 @@
 // Hook-bearing services live in .tsrx files with .ts shims so tsc's
 // moduleSuffixes can reach them (docs/module-resolution.md).
 export type {
-	AppState, BiometricsImpl, Capability, DeviceInfo, FileRef, HapticsImpl,
-	Insets, Locale, NotificationsImpl, PermissionKind, SecureStore,
-	ShareResult, WindowSize,
-} from './types';
-export { device } from './device';
-export { storage } from './storage';
-export { clipboard } from './clipboard';
-export { share } from './share';
-export { haptics } from './haptics';
-export { secureStorage } from './secure-storage';
-export { files } from './files';
-export { notifications } from './notifications';
-export { permissions } from './permissions';
-export { systemBars } from './system-bars';
-export { announce } from './a11y';
-export { locale } from './locale';
-export { media } from './media';
-export { biometrics } from './biometrics';
-export { onDeepLink, consumeInitialUrl } from './deep-links';
-export { useAppState, useBackHandler } from './lifecycle';
-export { useSafeAreaInsets } from './safe-area';
-export { useWindowSize } from './screen';
+	AppState,
+	AppInfo,
+	BiometricsImpl,
+	Capability,
+	ConnectionType,
+	ConnectivityImpl,
+	ConnectivityState,
+	DeviceInfo,
+	FileRef,
+	GeolocationImpl,
+	GeolocationOptions,
+	GeolocationPosition,
+	HapticsImpl,
+	PickedImage,
+	Insets,
+	Locale,
+	MediaImpl,
+	MediaPermissionKind,
+	NotificationsImpl,
+	PermissionKind,
+	PermissionResult,
+	OpenSettingsImpl,
+	SecureStore,
+	ShareResult,
+	WindowSize,
+} from './types'
+
+export { device } from './device'
+export { geolocation } from './geolocation'
+export { connectivity } from './connectivity'
+export { appInfo } from './app-info'
+export { openUrl, openSettings } from './open-url'
+export { storage } from './storage'
+export { clipboard } from './clipboard'
+export { share } from './share'
+export { haptics } from './haptics'
+export { secureStorage } from './secure-storage'
+export { files } from './files'
+export { notifications } from './notifications'
+export { permissions } from './permissions'
+export { systemBars } from './system-bars'
+export { announce } from './a11y'
+export { locale } from './locale'
+export { media } from './media'
+export { biometrics } from './biometrics'
+export { onDeepLink, consumeInitialUrl } from './deep-links'
+export { useAppState, useBackHandler } from './lifecycle'
+export { useSafeAreaInsets } from './safe-area'
+export { useWindowSize } from './screen'

package/src/lifecycle.native.ts

@@ -1 +1 @@
-export { useAppState, useBackHandler } from './lifecycle.native.tsrx';
+export { useAppState, useBackHandler } from './lifecycle.native.tsrx'

package/src/lifecycle.native.tsrx

@@ -20,6 +20,7 @@ export function useAppState(): AppState {
 			Application.off(Application.exitEvent, onExit);
 		};
 	}, []);
+
 	return state;
 }
 
@@ -30,6 +31,7 @@ export function useBackHandler(fn: () => boolean): void {
 		const cb = (e: { cancel: boolean }) => {
 			if (fn()) e.cancel = true;
 		};
+
 		Application.android.on(Application.AndroidApplication.activityBackPressedEvent, cb);
 		return () => {
 			Application.android.off(Application.AndroidApplication.activityBackPressedEvent, cb);

package/src/lifecycle.web.ts

@@ -1,2 +1,2 @@
 // tsc shim — moduleSuffixes doesn't reach .tsrx (see docs/module-resolution.md).
-export { useAppState, useBackHandler } from './lifecycle.web.tsrx';
+export { useAppState, useBackHandler } from './lifecycle.web.tsrx'

package/src/lifecycle.web.tsrx

@@ -17,6 +17,7 @@ export function useAppState(): AppState {
 			window.removeEventListener('pageshow', onVis);
 		};
 	}, []);
+
 	return state;
 }
 

package/src/locale.native.ts

@@ -1,9 +1,9 @@
 // Locale — Device.language/region on native.
-import { Device } from '@nativescript/core';
-import type { Locale } from './types';
+import { Device } from '@nativescript/core'
+import type { Locale } from './types'
 
 export const locale: Locale = {
 	tag: `${Device.language}-${Device.region}`,
 	language: Device.language.split('-')[0] ?? '',
 	region: Device.region,
-};
+}

package/src/locale.web.ts

@@ -1,12 +1,8 @@
 // Locale — navigator.language on web ("en-US" → tag + parts).
-export interface Locale {
-	tag: string;
-	language: string;
-	region: string;
-}
+import type { Locale } from './types'
 
 export const locale: Locale = (() => {
-	const tag = navigator.language ?? '';
-	const [language = '', region = ''] = tag.split('-');
-	return { tag, language, region };
-})();
+	const tag = navigator.language ?? ''
+	const [language = '', region = ''] = tag.split('-')
+	return { tag, language, region }
+})()

package/src/media.native.ts

@@ -1,15 +1,75 @@
-// Media picking — @nativescript/imagepicker presents the system picker and
-// yields ImageAssets; the FileRef uri is the asset's file path.
-import { create as createImagePicker } from '@nativescript/imagepicker';
-import type { FileRef } from './types';
-
-export const media = {
-	async pickImage(): Promise<FileRef | null> {
-		const picker = createImagePicker({ mode: 'single' });
-		await picker.authorize();
-		const [asset] = await picker.present();
-		if (!asset) return null;
-		const uri = (asset as any).ios ?? (asset as any).android ?? '';
-		return { name: 'image', uri: String(uri) };
+// Media picking — store a temporary JPEG for NativeScript Image and return a
+// data URL for APIs that persist image payloads.
+import { create as createImagePicker } from '@nativescript/imagepicker'
+// Ambient const enum — verbatimModuleSyntax forbids value access; Image = 1.
+import type { ImagePickerMediaType } from '@nativescript/imagepicker'
+import { ImageSource, knownFolders, path } from '@nativescript/core'
+import { files } from './files'
+import type { MediaImpl, MediaPermissionKind, PermissionResult, PickedImage } from './types'
+
+async function ensurePhotos(): Promise<PermissionResult> {
+	try {
+		const picker = createImagePicker({ mode: 'single', mediaType: 1 as ImagePickerMediaType })
+		const permission = (await picker.authorize()) as { authorized?: boolean } | boolean
+		return permission === true || (typeof permission === 'object' && permission.authorized === true)
+			? 'granted'
+			: 'denied'
+	} catch {
+		return 'denied'
+	}
+}
+
+async function pickSelections(mode: 'single' | 'multiple'): Promise<PickedImage[]> {
+	const picker = createImagePicker({ mode, mediaType: 1 as ImagePickerMediaType })
+	const permission = (await picker.authorize()) as { authorized?: boolean } | boolean
+	if (
+		!(permission === true || (typeof permission === 'object' && permission.authorized === true))
+	) {
+		return []
+	}
+
+	const selections = await picker.present()
+	const refs: PickedImage[] = []
+	try {
+		for (const selection of selections) {
+			const source = await ImageSource.fromAsset(selection.asset)
+			const filename = `octane-image-${Date.now()}-${Math.random().toString(36).slice(2)}.jpg`
+			const uri = path.join(knownFolders.temp().path, filename)
+			const ref = {
+				name: selection.originalFilename || selection.filename || 'image.jpg',
+				uri,
+			}
+
+			const saved = await source.saveToFileAsync(uri, 'jpeg', 85)
+			if (!saved) {
+				throw new Error('Could not save the selected image to temporary storage')
+			}
+
+			const base64 = await source.toBase64StringAsync('jpeg', 85)
+			refs.push({ ...ref, dataUrl: `data:image/jpeg;base64,${base64}` })
+		}
+
+		return refs
+	} catch (error) {
+		for (const ref of refs) {
+			files.release(ref)
+		}
+
+		throw error
+	}
+}
+
+export const media: MediaImpl = {
+	/** Opens the native image picker; returns null when canceled. */
+	async pickImage(): Promise<PickedImage | null> {
+		const [image] = await pickSelections('single')
+		return image ?? null
+	},
+	/** Opens the native image picker in multiple-selection mode. */
+	pickImages() {
+		return pickSelections('multiple')
+	},
+	async ensure(kind: MediaPermissionKind): Promise<PermissionResult> {
+		return kind === 'photos' ? ensurePhotos() : 'unsupported'
 	},
-};
+}