@octane-xplat/platform 0.1.0 → 0.4.0

package/src/media.web.ts

@@ -1,10 +1,72 @@
-// Media picking — web leaf. <input type=file accept="image/*"> → FileRef
-// (object URL). Multi-select stays out of v1.
-import type { FileRef } from './types';
-import { files } from './files';
-
-export const media = {
-	async pickImage(): Promise<FileRef | null> {
-		return files.pick('image/*');
+// Media picking — web leaf. Keep an object URL for previews and a data URL for
+// APIs that persist image payloads. The file input supports multiple photos.
+import type { MediaImpl, MediaPermissionKind, PermissionResult, PickedImage } from './types'
+
+function selectFiles(multiple: boolean): Promise<File[]> {
+	return new Promise((resolve) => {
+		const input = document.createElement('input')
+		input.type = 'file'
+		input.accept = 'image/*'
+		input.multiple = multiple
+		input.onchange = () => resolve(Array.from(input.files ?? []))
+		input.oncancel = () => resolve([])
+		input.click()
+	})
+}
+
+function readDataUrl(file: File): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader()
+		reader.onload = () => {
+			if (typeof reader.result === 'string') {
+				resolve(reader.result)
+			} else {
+				reject(new Error('Could not read the selected image'))
+			}
+		}
+
+		reader.onerror = () => reject(reader.error ?? new Error('Could not read the selected image'))
+
+		reader.readAsDataURL(file)
+	})
+}
+
+async function pickFiles(multiple: boolean): Promise<PickedImage[]> {
+	const selected = await selectFiles(multiple)
+	return Promise.all(
+		selected.map(async (file) => ({
+			name: file.name,
+			uri: URL.createObjectURL(file),
+			dataUrl: await readDataUrl(file),
+		})),
+	)
+}
+
+export const media: MediaImpl = {
+	/** Opens the browser image picker; returns null when selection is canceled. */
+	async pickImage(): Promise<PickedImage | null> {
+		const [image] = await pickFiles(false)
+		return image ?? null
+	},
+	/** Opens the browser image picker with multiple selection enabled. */
+	pickImages() {
+		return pickFiles(true)
+	},
+	async ensure(kind: MediaPermissionKind): Promise<PermissionResult> {
+		if (kind === 'photos') {
+			return typeof document !== 'undefined' ? 'granted' : 'unsupported'
+		}
+
+		if (!navigator.mediaDevices?.getUserMedia) {
+			return 'unsupported'
+		}
+
+		try {
+			const stream = await navigator.mediaDevices.getUserMedia({ video: true })
+			stream.getTracks().forEach((track) => track.stop())
+			return 'granted'
+		} catch {
+			return 'denied'
+		}
 	},
-};
+}

package/src/notifications.native.ts

@@ -1,18 +1,18 @@
 // Notifications — local notifications via plugin; push (APNs/FCM) is an
 // app-level concern, not this seam.
-import { LocalNotifications } from '@nativescript/local-notifications';
-import type { Capability } from './types';
-import type { NotificationsImpl } from './types';
+import { LocalNotifications } from '@nativescript/local-notifications'
+import type { Capability } from './types'
+import type { NotificationsImpl } from './types'
 
 export const notifications: Capability<NotificationsImpl> = {
 	supported: true,
 	async ensure() {
-		const granted = await LocalNotifications.requestPermission();
-		return granted ? 'granted' : 'denied';
+		const granted = await LocalNotifications.requestPermission()
+		return granted ? 'granted' : 'denied'
 	},
 	impl: {
 		notify(title, body) {
-			LocalNotifications.schedule([{ id: Date.now() % 2147483647, title, body: body ?? '' }]);
+			LocalNotifications.schedule([{ id: Date.now() % 2147483647, title, body: body ?? '' }])
 		},
 	},
-};
+}

package/src/notifications.web.ts

@@ -1,18 +1,29 @@
 // Notifications — Web Notification API. ensure() maps permission state;
 // notify() posts an immediate local notification (no push).
-import type { Capability, NotificationsImpl } from './types';
+import type { Capability, NotificationsImpl } from './types'
 
 export const notifications: Capability<NotificationsImpl> = {
 	supported: typeof Notification !== 'undefined',
 	async ensure() {
-		if (typeof Notification === 'undefined') return 'unsupported';
-		if (Notification.permission === 'granted') return 'granted';
-		if (Notification.permission === 'denied') return 'denied';
-		return (await Notification.requestPermission()) === 'granted' ? 'granted' : 'denied';
+		if (typeof Notification === 'undefined') {
+			return 'unsupported'
+		}
+
+		if (Notification.permission === 'granted') {
+			return 'granted'
+		}
+
+		if (Notification.permission === 'denied') {
+			return 'denied'
+		}
+
+		return (await Notification.requestPermission()) === 'granted' ? 'granted' : 'denied'
 	},
 	impl: {
 		notify(title, body) {
-			if (Notification.permission === 'granted') new Notification(title, { body });
+			if (Notification.permission === 'granted') {
+				new Notification(title, { body })
+			}
 		},
 	},
-};
+}

package/src/open-url.native.ts

@@ -0,0 +1,45 @@
+// Outbound links and app settings — native leaf. Settings use the public
+// per-app settings route on each platform, not private iOS prefs URLs.
+import { Application, Utils } from '@nativescript/core'
+import type { Capability, OpenSettingsImpl } from './types'
+
+export function openUrl(url: string): boolean {
+	return Utils.openUrl(url)
+}
+
+function openSettingsPage(): boolean {
+	try {
+		if (Application.ios) {
+			const settingsUrl = (globalThis as any).UIApplicationOpenSettingsURLString ?? 'app-settings:'
+			return Utils.openUrl(settingsUrl)
+		}
+
+		if (Application.android) {
+			const activity = Utils.android.getCurrentActivity()
+
+			if (!activity) {
+				return false
+			}
+
+			const intent = new android.content.Intent(
+				(android.provider.Settings as any).ACTION_APPLICATION_DETAILS_SETTINGS,
+			)
+
+			intent.setData(android.net.Uri.parse(`package:${Utils.android.getPackageName()}`))
+			activity.startActivity(intent)
+			return true
+		}
+	} catch {
+		return false
+	}
+
+	return false
+}
+
+export const openSettings: Capability<OpenSettingsImpl> = {
+	supported: true,
+	async ensure() {
+		return 'granted'
+	},
+	impl: { open: openSettingsPage },
+}

package/src/open-url.web.ts

@@ -0,0 +1,15 @@
+// Outbound links — web leaf. Settings are an app-level concept and are
+// explicitly unsupported in a browser.
+import type { Capability, OpenSettingsImpl } from './types'
+
+export function openUrl(url: string): boolean {
+	return window.open(url, '_blank', 'noopener,noreferrer') !== null
+}
+
+export const openSettings: Capability<OpenSettingsImpl> = {
+	supported: false,
+	async ensure() {
+		return 'unsupported'
+	},
+	impl: null,
+}

package/src/permissions.native.ts

@@ -1,20 +1,20 @@
-// Runtime permissions — native leaf. Maps the shared kind union onto the
-// owning plugin's request call; add kinds as services land.
-import { LocalNotifications } from '@nativescript/local-notifications';
-import type { PermissionKind } from './types';
+// Runtime permissions — native leaf. Delegate each kind to the service that
+// owns its plugin request, so this generic seam cannot drift from reality.
+import { geolocation } from './geolocation'
+import { media } from './media'
+import { notifications } from './notifications'
+import type { PermissionKind } from './types'
 
 export const permissions = {
 	async ensure(kind: PermissionKind): Promise<'granted' | 'denied' | 'unsupported'> {
 		switch (kind) {
 			case 'notifications':
-				return (await LocalNotifications.requestPermission()) ? 'granted' : 'denied';
-			// camera/photos/location have dedicated plugins — the owning
-			// service leaf (media, geolocation) owns its own ensure(); this
-			// generic seam reports them unsupported until wired.
+				return notifications.ensure()
 			case 'camera':
 			case 'photos':
+				return media.ensure(kind)
 			case 'location':
-				return 'unsupported';
+				return geolocation.ensure()
 		}
 	},
-};
+}

package/src/permissions.web.ts

@@ -1,38 +1,20 @@
-// Runtime permissions — web leaf. Browsers grant most capabilities per-API
-// (clipboard/notification have their own ensure()); this generic seam covers
-// feature-detection for the rest.
-export type PermissionKind = 'notifications' | 'camera' | 'photos' | 'location';
+// Runtime permissions — web leaf. Each kind delegates to its owning service;
+// browser feature detection and prompts therefore stay at the platform edge.
+import { geolocation } from './geolocation'
+import { media } from './media'
+import { notifications } from './notifications'
+import type { PermissionKind } from './types'
 
 export const permissions = {
 	async ensure(kind: PermissionKind): Promise<'granted' | 'denied' | 'unsupported'> {
 		switch (kind) {
-			case 'notifications': {
-				if (typeof Notification === 'undefined') return 'unsupported';
-				if (Notification.permission === 'granted') return 'granted';
-				if (Notification.permission === 'denied') return 'denied';
-				return (await Notification.requestPermission()) === 'granted' ? 'granted' : 'denied';
-			}
+			case 'notifications':
+				return notifications.ensure()
 			case 'camera':
-			case 'photos': {
-				if (!navigator.mediaDevices?.getUserMedia) return 'unsupported';
-				try {
-					const s = await navigator.mediaDevices.getUserMedia({ video: true });
-					s.getTracks().forEach((t) => t.stop());
-					return 'granted';
-				} catch {
-					return 'denied';
-				}
-			}
-			case 'location': {
-				if (!('geolocation' in navigator)) return 'unsupported';
-				return new Promise((resolve) =>
-					navigator.geolocation.getCurrentPosition(
-						() => resolve('granted'),
-						(e) => resolve(e.code === e.PERMISSION_DENIED ? 'denied' : 'unsupported'),
-						{ timeout: 15000 },
-					),
-				);
-			}
+			case 'photos':
+				return media.ensure(kind)
+			case 'location':
+				return geolocation.ensure()
 		}
 	},
-};
+}

package/src/safe-area.native.ts

@@ -1 +1 @@
-export { useSafeAreaInsets } from './safe-area.native.tsrx';
+export { useSafeAreaInsets } from './safe-area.native.tsrx'

package/src/safe-area.native.tsrx

@@ -1,27 +1,86 @@
-// Safe-area insets — native leaf. Reads the window's safe area after layout;
-// falls back to zero before it exists.
-import { useEffect, useState } from 'octane';
-import type { Insets } from './types';
-import { Application } from '@nativescript/core';
+/** @jsxImportSource @nativescript-community/octane */
+// Safe-area insets — native leaf. iOS reads UIView.safeAreaInsets; Android
+// reads the foreground activity's root WindowInsets in device-independent px.
+import { useEffect, useState } from 'octane'
+import { Application, Screen } from '@nativescript/core'
+import type { Insets } from './types'
 
+const zeroInsets = (): Insets => ({ top: 0, bottom: 0, left: 0, right: 0 })
+
+function androidActivity(): any {
+	return Application.android?.foregroundActivity ?? Application.android?.startActivity
+}
+
+function readAndroidInsets(windowInsets?: any): Insets {
+	const activity = androidActivity()
+	const decorView = activity?.getWindow?.()?.getDecorView?.()
+	const insets = windowInsets ?? decorView?.getRootWindowInsets?.()
+	if (!insets) return zeroInsets()
+
+	const scale = Screen.mainScreen.scale || 1
+	if (android.os.Build.VERSION.SDK_INT >= 30) {
+		const systemBars =
+			android.view.WindowInsets.Type.systemBars() | android.view.WindowInsets.Type.displayCutout()
+
+		const i = insets.getInsets(systemBars)
+		return {
+			top: i.top / scale,
+			bottom: i.bottom / scale,
+			left: i.left / scale,
+			right: i.right / scale,
+		}
+	}
+
+	return {
+		top: insets.getSystemWindowInsetTop() / scale,
+		bottom: insets.getSystemWindowInsetBottom() / scale,
+		left: insets.getSystemWindowInsetLeft() / scale,
+		right: insets.getSystemWindowInsetRight() / scale,
+	}
+}
 
 function readInsets(): Insets {
 	if (Application.ios) {
-		const v = Application.ios.rootController?.view;
-		const i = v?.safeAreaInsets;
-		if (i) return { top: i.top, bottom: i.bottom, left: i.left, right: i.right };
+		const i = Application.ios.rootController?.view?.safeAreaInsets
+		if (i) return { top: i.top, bottom: i.bottom, left: i.left, right: i.right }
 	}
-	// Android: WindowInsets need an attached view — return 0 until a screen
-	// supplies its own; orientation change re-reads.
-	return { top: 0, bottom: 0, left: 0, right: 0 };
+
+	if (Application.android) return readAndroidInsets()
+	return zeroInsets()
+}
+
+function watchAndroidInsets(update: (insets: Insets) => void): () => void {
+	const decorView = androidActivity()?.getWindow?.()?.getDecorView?.()
+	if (!decorView) return () => {}
+
+	const listener = new android.view.View.OnApplyWindowInsetsListener({
+		onApplyWindowInsets(_view: any, insets: any) {
+			update(readAndroidInsets(insets))
+			return insets
+		},
+	})
+
+	decorView.setOnApplyWindowInsetsListener(listener)
+	decorView.requestApplyInsets?.()
+
+	return () => decorView.setOnApplyWindowInsetsListener(null)
 }
 
 export function useSafeAreaInsets(): Insets {
-	const [insets, setInsets] = useState<Insets>(readInsets);
+	const [insets, setInsets] = useState<Insets>(readInsets)
 	useEffect(() => {
-		const update = () => setInsets(readInsets());
-		Application.on(Application.orientationChangedEvent, update);
-		return () => Application.off(Application.orientationChangedEvent, update);
-	}, []);
-	return insets;
+		const update = () => setInsets(readInsets())
+		Application.on(Application.orientationChangedEvent, update)
+		Application.on(Application.resumeEvent, update)
+		const stopWatchingAndroid = Application.android ? watchAndroidInsets(setInsets) : () => {}
+		update()
+
+		return () => {
+			Application.off(Application.orientationChangedEvent, update)
+			Application.off(Application.resumeEvent, update)
+			stopWatchingAndroid()
+		}
+	}, [])
+
+	return insets
 }

package/src/safe-area.web.ts

@@ -1 +1 @@
-export { useSafeAreaInsets } from './safe-area.web.tsrx';
+export { useSafeAreaInsets } from './safe-area.web.tsrx'

package/src/safe-area.web.tsrx

@@ -10,6 +10,7 @@ function measure(): Insets {
 		'position:fixed;top:0;left:0;pointer-events:none;visibility:hidden;' +
 		'padding-top:env(safe-area-inset-top);padding-bottom:env(safe-area-inset-bottom);' +
 		'padding-left:env(safe-area-inset-left);padding-right:env(safe-area-inset-right);';
+
 	document.body.appendChild(probe);
 	const cs = getComputedStyle(probe);
 	const insets = {
@@ -18,6 +19,7 @@ function measure(): Insets {
 		left: parseFloat(cs.paddingLeft) || 0,
 		right: parseFloat(cs.paddingRight) || 0,
 	};
+
 	probe.remove();
 	return insets;
 }
@@ -30,5 +32,6 @@ export function useSafeAreaInsets(): Insets {
 		window.addEventListener('resize', update);
 		return () => window.removeEventListener('resize', update);
 	}, []);
+
 	return insets;
 }

package/src/screen.native.ts

@@ -1 +1 @@
-export { useWindowSize } from './screen.native.tsrx';
+export { useWindowSize } from './screen.native.tsrx'

package/src/screen.native.tsrx

@@ -21,5 +21,6 @@ export function useWindowSize(): WindowSize {
 		Application.on(Application.orientationChangedEvent, update);
 		return () => Application.off(Application.orientationChangedEvent, update);
 	}, []);
+
 	return size;
 }

package/src/screen.web.ts

@@ -1 +1 @@
-export { useWindowSize } from './screen.web.tsrx';
+export { useWindowSize } from './screen.web.tsrx'

package/src/screen.web.tsrx

@@ -22,5 +22,6 @@ export function useWindowSize(): WindowSize {
 			window.removeEventListener('orientationchange', update);
 		};
 	}, []);
+
 	return size;
 }

package/src/secure-storage.native.ts

@@ -1,9 +1,9 @@
 // Secure storage — Keychain (iOS) / Keystore (Android) via plugin.
-import { SecureStorage } from '@nativescript/secure-storage';
-import type { Capability } from './types';
-import type { SecureStore } from './types';
+import { SecureStorage } from '@nativescript/secure-storage'
+import type { Capability } from './types'
+import type { SecureStore } from './types'
 
-const store = new SecureStorage();
+const store = new SecureStorage()
 
 export const secureStorage: Capability<SecureStore> = {
 	supported: true,
@@ -14,4 +14,4 @@ export const secureStorage: Capability<SecureStore> = {
 		set: (key, value) => store.set({ key, value }),
 		remove: (key) => store.remove({ key }),
 	},
-};
+}

package/src/secure-storage.web.ts

@@ -1,10 +1,10 @@
 // Secure storage — web has no equivalent trust boundary (IndexedDB is not
 // secure enclave storage). Declared unsupported per the Capability contract;
 // callers must branch on `supported` rather than catching.
-import type { Capability, SecureStore } from './types';
+import type { Capability, SecureStore } from './types'
 
 export const secureStorage: Capability<SecureStore> = {
 	supported: false,
 	ensure: async () => 'unsupported',
 	impl: null,
-};
+}

package/src/share.native.ts

@@ -1,13 +1,13 @@
 // Share — native share sheet via @nativescript/social-share.
-import { shareText, shareUrl } from '@nativescript/social-share';
+import { shareText, shareUrl } from '@nativescript/social-share'
 
 export const share = {
 	async text(text: string, subject?: string): Promise<'shared'> {
-		shareText(text, subject);
-		return 'shared';
+		shareText(text, subject)
+		return 'shared'
 	},
 	async url(url: string, title?: string): Promise<'shared'> {
-		shareUrl(url, title ?? url);
-		return 'shared';
+		shareUrl(url, title ?? url)
+		return 'shared'
 	},
-};
+}

package/src/share.web.ts

@@ -2,27 +2,31 @@
 // desktop degrades to clipboard copy so the call still does something useful.
 export const share = {
 	async text(text: string, subject?: string): Promise<'shared' | 'copied' | 'unavailable'> {
-		const nav = navigator as any;
+		const nav = navigator as any
 		if (nav.share) {
-			await nav.share({ text, title: subject });
-			return 'shared';
+			await nav.share({ text, title: subject })
+			return 'shared'
 		}
+
 		if (nav.clipboard) {
-			await nav.clipboard.writeText(text);
-			return 'copied';
+			await nav.clipboard.writeText(text)
+			return 'copied'
 		}
-		return 'unavailable';
+
+		return 'unavailable'
 	},
 	async url(url: string, title?: string): Promise<'shared' | 'copied' | 'unavailable'> {
-		const nav = navigator as any;
+		const nav = navigator as any
 		if (nav.share) {
-			await nav.share({ url, title });
-			return 'shared';
+			await nav.share({ url, title })
+			return 'shared'
 		}
+
 		if (nav.clipboard) {
-			await nav.clipboard.writeText(url);
-			return 'copied';
+			await nav.clipboard.writeText(url)
+			return 'copied'
 		}
-		return 'unavailable';
+
+		return 'unavailable'
 	},
-};
+}

package/src/storage.native.ts

@@ -1,10 +1,14 @@
-import { ApplicationSettings } from '@nativescript/core';
+import { ApplicationSettings } from '@nativescript/core'
 
 /** Sync KV seam — NS ApplicationSettings (NSUserDefaults) on native,
  *  the web leaf uses the DOM's string store. String-only for v1;
  *  serialize objects at the edge. */
 export const storage = {
 	getString: (k: string): string | null => ApplicationSettings.getString(k) ?? null,
-	setString: (k: string, v: string): void => { ApplicationSettings.setString(k, v); },
-	remove: (k: string): void => { ApplicationSettings.remove(k); },
-};
+	setString: (k: string, v: string): void => {
+		ApplicationSettings.setString(k, v)
+	},
+	remove: (k: string): void => {
+		ApplicationSettings.remove(k)
+	},
+}

package/src/storage.web.ts

@@ -1,6 +1,10 @@
 /** Sync KV seam — localStorage on web. */
 export const storage = {
 	getString: (k: string): string | null => localStorage.getItem(k),
-	setString: (k: string, v: string): void => { localStorage.setItem(k, v); },
-	remove: (k: string): void => { localStorage.removeItem(k); },
-};
+	setString: (k: string, v: string): void => {
+		localStorage.setItem(k, v)
+	},
+	remove: (k: string): void => {
+		localStorage.removeItem(k)
+	},
+}

package/src/system-bars.native.ts

@@ -1,22 +1,24 @@
 // Status/nav bars — native leaf. iOS status-bar style + Android
 // navigation-bar color via the application window.
-import { Application, Color } from '@nativescript/core';
+import { Application, Color } from '@nativescript/core'
 
 export const systemBars = {
 	setStatusBarStyle(style: 'light' | 'dark'): void {
 		if (Application.ios) {
-			const app = Application.ios.nativeApp;
+			const app = Application.ios.nativeApp
+
 			// NS 9: per-page statusBarStyle is the preferred seam; fall back to
 			// the app-level setter on older systems.
-			(app as any)?.setStatusBarStyle?.(style === 'light' ? 1 : 0);
+
+			;(app as any)?.setStatusBarStyle?.(style === 'light' ? 1 : 0)
 		}
 	},
 	setColor(color: string): void {
-		const c = new Color(color);
+		const c = new Color(color)
 		if (Application.android?.startActivity) {
-			const win = Application.android.startActivity.getWindow();
-			win.setStatusBarColor(c.android);
-			win.setNavigationBarColor(c.android);
+			const win = Application.android.startActivity.getWindow()
+			win.setStatusBarColor(c.android)
+			win.setNavigationBarColor(c.android)
 		}
 	},
-};
+}

package/src/system-bars.web.ts

@@ -1,14 +1,17 @@
 // Status/nav bars — web leaf. No status bar on web, but theme-color is the
 // honest equivalent: it tints mobile browser chrome.
 export const systemBars = {
+	// Browsers do not expose a status-bar icon-style API. `setColor` below is
+	// the available theme-color equivalent; this method intentionally no-ops.
 	setStatusBarStyle(_style: 'light' | 'dark'): void {},
 	setColor(color: string): void {
-		let meta = document.querySelector('meta[name="theme-color"]');
+		let meta = document.querySelector('meta[name="theme-color"]')
 		if (!meta) {
-			meta = document.createElement('meta');
-			meta.setAttribute('name', 'theme-color');
-			document.head.appendChild(meta);
+			meta = document.createElement('meta')
+			meta.setAttribute('name', 'theme-color')
+			document.head.appendChild(meta)
 		}
-		meta.setAttribute('content', color);
+
+		meta.setAttribute('content', color)
 	},
-};
+}