@ng-native/expo 0.0.1 → 0.1.0

package/dist/image-picker.js

@@ -0,0 +1,58 @@
+/**
+ * `ImagePicker`, bound to `expo-image-picker`.
+ *
+ * ```ts
+ * private readonly picker = inject(ImagePicker);
+ * const [photo] = await this.picker.pick({ mediaTypes: ['images'] });
+ * ```
+ *
+ * The options are Expo's own, passed through unchanged. What this adds is the two things every
+ * call site otherwise writes: a cancelled picker answers with no assets rather than a result to
+ * unwrap, and `capture()` asks for the camera before opening it, where Expo's would reject.
+ */
+import { InjectionToken, Service, inject } from '@angular/core';
+import { expoModule } from "./native.js";
+import { Permission } from "./permissions.js";
+import * as i0 from "@angular/core";
+/** What a permission is without the module: refused, and never to be asked about. */
+const UNAVAILABLE = async () => ({
+    status: 'denied',
+    granted: false,
+    canAskAgain: false,
+});
+export class ImagePicker {
+    /** Overridden in a test to pick photos without a photo library. */
+    static SOURCE = new InjectionToken('angular-native.imagePickerSource', {
+        factory: () => expoModule('expo-image-picker', () => require('expo-image-picker')) ??
+            null,
+    });
+    native = inject(ImagePicker.SOURCE);
+    /**
+     * The photo library. The system picker needs no permission to pick from, so `pick()` never
+     * asks; this is for an app that reads the library itself.
+     */
+    libraryPermission = Permission.of(this.native?.getMediaLibraryPermissionsAsync ?? UNAVAILABLE, this.native?.requestMediaLibraryPermissionsAsync ?? UNAVAILABLE);
+    /** The camera, which `capture()` asks for itself. */
+    cameraPermission = Permission.of(this.native?.getCameraPermissionsAsync ?? UNAVAILABLE, this.native?.requestCameraPermissionsAsync ?? UNAVAILABLE);
+    /** Pick from the photo library. Empty if they cancelled. */
+    async pick(options) {
+        if (!this.native)
+            return [];
+        return assetsOf(await this.native.launchImageLibraryAsync(options));
+    }
+    /** Take a photo or video with the system camera. Empty if they cancelled or refused it. */
+    async capture(options) {
+        if (!this.native || !(await this.cameraPermission.ensure()))
+            return [];
+        return assetsOf(await this.native.launchCameraAsync(options));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ImagePicker, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: ImagePicker });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ImagePicker, decorators: [{
+            type: Service
+        }] });
+function assetsOf(result) {
+    return result.canceled ? [] : (result.assets ?? []);
+}
+//# sourceMappingURL=image-picker.js.map

package/dist/image-picker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-picker.js","sourceRoot":"","sources":["../src/image-picker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,UAAU,EAA2B,MAAM,kBAAkB,CAAC;;AAoBvE,qFAAqF;AACrF,MAAM,WAAW,GAAG,KAAK,IAAiC,EAAE,CAAC,CAAC;IAC5D,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,KAAK;IACd,WAAW,EAAE,KAAK;CACnB,CAAC,CAAC;AAGH,MAAM,OAAO,WAAW;IACtB,mEAAmE;IACnE,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,kCAAkC,EAClC;QACE,OAAO,EAAE,GAAG,EAAE,CACZ,UAAU,CAAC,mBAAmB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,mBAAmB,CAAsB,CAAC;YACxF,IAAI;KACP,CACF,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAErD;;;OAGG;IACM,iBAAiB,GAAG,UAAU,CAAC,EAAE,CACxC,IAAI,CAAC,MAAM,EAAE,+BAA+B,IAAI,WAAW,EAC3D,IAAI,CAAC,MAAM,EAAE,mCAAmC,IAAI,WAAW,CAChE,CAAC;IAEF,qDAAqD;IAC5C,gBAAgB,GAAG,UAAU,CAAC,EAAE,CACvC,IAAI,CAAC,MAAM,EAAE,yBAAyB,IAAI,WAAW,EACrD,IAAI,CAAC,MAAM,EAAE,6BAA6B,IAAI,WAAW,CAC1D,CAAC;IAEF,4DAA4D;IAC5D,KAAK,CAAC,IAAI,CAAC,OAAuB;QAChC,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,EAAE,CAAC;QAC5B,OAAO,QAAQ,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,CAAC;IACtE,CAAC;IAED,2FAA2F;IAC3F,KAAK,CAAC,OAAO,CAAC,OAAuB;QACnC,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC;YAAE,OAAO,EAAE,CAAC;QACvE,OAAO,QAAQ,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;IAChE,CAAC;uGAtCU,WAAW;wGAAX,WAAW;;2FAAX,WAAW;kBADvB,OAAO;;AA0CR,SAAS,QAAQ,CAAC,MAAoB;IACpC,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;AACtD,CAAC","sourcesContent":["/**\n * `ImagePicker`, bound to `expo-image-picker`.\n *\n * ```ts\n * private readonly picker = inject(ImagePicker);\n * const [photo] = await this.picker.pick({ mediaTypes: ['images'] });\n * ```\n *\n * The options are Expo's own, passed through unchanged. What this adds is the two things every\n * call site otherwise writes: a cancelled picker answers with no assets rather than a result to\n * unwrap, and `capture()` asks for the camera before opening it, where Expo's would reject.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport { expoModule } from './native.ts';\nimport { Permission, type PermissionResponse } from './permissions.ts';\n\nexport type PickerOptions = import('expo-image-picker').ImagePickerOptions;\nexport type PickedAsset = import('expo-image-picker').ImagePickerAsset;\n\n/** The slice of `expo-image-picker` this needs. */\nexport interface NativeImagePicker {\n  launchImageLibraryAsync(options?: PickerOptions): Promise<PickerResult>;\n  launchCameraAsync(options?: PickerOptions): Promise<PickerResult>;\n  getMediaLibraryPermissionsAsync(): Promise<PermissionResponse>;\n  requestMediaLibraryPermissionsAsync(): Promise<PermissionResponse>;\n  getCameraPermissionsAsync(): Promise<PermissionResponse>;\n  requestCameraPermissionsAsync(): Promise<PermissionResponse>;\n}\n\ninterface PickerResult {\n  readonly canceled: boolean;\n  readonly assets: readonly PickedAsset[] | null;\n}\n\n/** What a permission is without the module: refused, and never to be asked about. */\nconst UNAVAILABLE = async (): Promise<PermissionResponse> => ({\n  status: 'denied',\n  granted: false,\n  canAskAgain: false,\n});\n\n@Service()\nexport class ImagePicker {\n  /** Overridden in a test to pick photos without a photo library. */\n  static readonly SOURCE = new InjectionToken<NativeImagePicker | null>(\n    'angular-native.imagePickerSource',\n    {\n      factory: () =>\n        expoModule('expo-image-picker', () => require('expo-image-picker') as NativeImagePicker) ??\n        null,\n    },\n  );\n\n  private readonly native = inject(ImagePicker.SOURCE);\n\n  /**\n   * The photo library. The system picker needs no permission to pick from, so `pick()` never\n   * asks; this is for an app that reads the library itself.\n   */\n  readonly libraryPermission = Permission.of(\n    this.native?.getMediaLibraryPermissionsAsync ?? UNAVAILABLE,\n    this.native?.requestMediaLibraryPermissionsAsync ?? UNAVAILABLE,\n  );\n\n  /** The camera, which `capture()` asks for itself. */\n  readonly cameraPermission = Permission.of(\n    this.native?.getCameraPermissionsAsync ?? UNAVAILABLE,\n    this.native?.requestCameraPermissionsAsync ?? UNAVAILABLE,\n  );\n\n  /** Pick from the photo library. Empty if they cancelled. */\n  async pick(options?: PickerOptions): Promise<readonly PickedAsset[]> {\n    if (!this.native) return [];\n    return assetsOf(await this.native.launchImageLibraryAsync(options));\n  }\n\n  /** Take a photo or video with the system camera. Empty if they cancelled or refused it. */\n  async capture(options?: PickerOptions): Promise<readonly PickedAsset[]> {\n    if (!this.native || !(await this.cameraPermission.ensure())) return [];\n    return assetsOf(await this.native.launchCameraAsync(options));\n  }\n}\n\nfunction assetsOf(result: PickerResult): readonly PickedAsset[] {\n  return result.canceled ? [] : (result.assets ?? []);\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * What the package exports without naming a module.
+ *
+ * Everything with an Expo module behind it has its own entry point - `@ng-native/expo/
+ * battery.ts` and friends - so that importing haptics does not make an app install the video
+ * player. What is left here is the shared machinery: the permission shape every module spells
+ * identically, the signal-from-a-listener those services are built out of, and the view names.
+ */
+export { observed, type Observed } from './observed.ts';
+export { Permission, type PermissionApi, type PermissionResponse } from './permissions.ts';
+export { MissingModuleError, expoModule, optional, type ModulePlatform } from './native.ts';
+export { NATIVE_VIEWS, registerNativeViews } from './community-views.ts';
+export { registerExpoUiViews } from './expo-ui.ts';
+export { nativeState, type NativeState } from './native-state.ts';
+export { EXPO_VIEWS, expoViewName, registerExpoView, registerExpoViews, type ExpoViewOptions, } from './register-expo-view.ts';
+export { UiButton, UiDatePicker, UiDivider, UiHost, UiImage, UiMenu, UiPicker, UiColorPicker, type UiColorChangeEvent, UiForm, UiGauge, UiHStack, UiLabeledContent, UiList, UiProgress, UiSection, UiSpacer, UiStepper, type UiStepperChangeEvent, UiTextField, type UiTextFieldChangeEvent, UiToggle, type UiToggleChangeEvent, UiSlider, type UiSliderChangeEvent, UiSlot, UiSwipeActions, UiText, UiVStack, type UiDateChangeEvent, type UiPickerOption, type UiModifier, } from './expo-ui-components.ts';
+export { ExpoImage, type ExpoImageContentFit, type ExpoImageSource } from './expo-image.ts';
+export { ExpoGlass, ExpoGlassContainer, liquidGlassAvailable, type GlassEffectStyleConfig, type GlassStyle, } from './glass.ts';
+export { ExpoSymbol, type SymbolAnimationSpec, type SymbolResizeMode, type SymbolScale, type SymbolType, type SymbolWeight, } from './symbol.ts';
+export { SegmentedControl, type SegmentedControlChangeEvent, type SegmentedControlFont, } from './segmented-control.ts';

package/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * What the package exports without naming a module.
+ *
+ * Everything with an Expo module behind it has its own entry point - `@ng-native/expo/
+ * battery.ts` and friends - so that importing haptics does not make an app install the video
+ * player. What is left here is the shared machinery: the permission shape every module spells
+ * identically, the signal-from-a-listener those services are built out of, and the view names.
+ */
+export { observed } from "./observed.js";
+export { Permission } from "./permissions.js";
+export { MissingModuleError, expoModule, optional } from "./native.js";
+export { NATIVE_VIEWS, registerNativeViews } from "./community-views.js";
+export { registerExpoUiViews } from "./expo-ui.js";
+export { nativeState } from "./native-state.js";
+export { EXPO_VIEWS, expoViewName, registerExpoView, registerExpoViews, } from "./register-expo-view.js";
+export { UiButton, UiDatePicker, UiDivider, UiHost, UiImage, UiMenu, UiPicker, UiColorPicker, UiForm, UiGauge, UiHStack, UiLabeledContent, UiList, UiProgress, UiSection, UiSpacer, UiStepper, UiTextField, UiToggle, UiSlider, UiSlot, UiSwipeActions, UiText, UiVStack, } from "./expo-ui-components.js";
+export { ExpoImage } from "./expo-image.js";
+export { ExpoGlass, ExpoGlassContainer, liquidGlassAvailable, } from "./glass.js";
+export { ExpoSymbol, } from "./symbol.js";
+export { SegmentedControl, } from "./segmented-control.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,QAAQ,EAAiB,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,UAAU,EAA+C,MAAM,kBAAkB,CAAC;AAC3F,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,QAAQ,EAAuB,MAAM,aAAa,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AAClE,OAAO,EACL,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAElB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,MAAM,EACN,OAAO,EACP,MAAM,EACN,QAAQ,EACR,aAAa,EAEb,MAAM,EACN,OAAO,EACP,QAAQ,EACR,gBAAgB,EAChB,MAAM,EACN,UAAU,EACV,SAAS,EACT,QAAQ,EACR,SAAS,EAET,WAAW,EAEX,QAAQ,EAER,QAAQ,EAER,MAAM,EACN,cAAc,EACd,MAAM,EACN,QAAQ,GAIT,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,SAAS,EAAkD,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,oBAAoB,GAGrB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,UAAU,GAMX,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,gBAAgB,GAGjB,MAAM,wBAAwB,CAAC","sourcesContent":["/**\n * What the package exports without naming a module.\n *\n * Everything with an Expo module behind it has its own entry point - `@ng-native/expo/\n * battery.ts` and friends - so that importing haptics does not make an app install the video\n * player. What is left here is the shared machinery: the permission shape every module spells\n * identically, the signal-from-a-listener those services are built out of, and the view names.\n */\nexport { observed, type Observed } from './observed.ts';\nexport { Permission, type PermissionApi, type PermissionResponse } from './permissions.ts';\nexport { MissingModuleError, expoModule, optional, type ModulePlatform } from './native.ts';\nexport { NATIVE_VIEWS, registerNativeViews } from './community-views.ts';\nexport { registerExpoUiViews } from './expo-ui.ts';\nexport { nativeState, type NativeState } from './native-state.ts';\nexport {\n  EXPO_VIEWS,\n  expoViewName,\n  registerExpoView,\n  registerExpoViews,\n  type ExpoViewOptions,\n} from './register-expo-view.ts';\nexport {\n  UiButton,\n  UiDatePicker,\n  UiDivider,\n  UiHost,\n  UiImage,\n  UiMenu,\n  UiPicker,\n  UiColorPicker,\n  type UiColorChangeEvent,\n  UiForm,\n  UiGauge,\n  UiHStack,\n  UiLabeledContent,\n  UiList,\n  UiProgress,\n  UiSection,\n  UiSpacer,\n  UiStepper,\n  type UiStepperChangeEvent,\n  UiTextField,\n  type UiTextFieldChangeEvent,\n  UiToggle,\n  type UiToggleChangeEvent,\n  UiSlider,\n  type UiSliderChangeEvent,\n  UiSlot,\n  UiSwipeActions,\n  UiText,\n  UiVStack,\n  type UiDateChangeEvent,\n  type UiPickerOption,\n  type UiModifier,\n} from './expo-ui-components.ts';\nexport { ExpoImage, type ExpoImageContentFit, type ExpoImageSource } from './expo-image.ts';\nexport {\n  ExpoGlass,\n  ExpoGlassContainer,\n  liquidGlassAvailable,\n  type GlassEffectStyleConfig,\n  type GlassStyle,\n} from './glass.ts';\nexport {\n  ExpoSymbol,\n  type SymbolAnimationSpec,\n  type SymbolResizeMode,\n  type SymbolScale,\n  type SymbolType,\n  type SymbolWeight,\n} from './symbol.ts';\nexport {\n  SegmentedControl,\n  type SegmentedControlChangeEvent,\n  type SegmentedControlFont,\n} from './segmented-control.ts';\n"]}

package/dist/keep-awake.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `KeepAwake`, bound to `expo-keep-awake`.
+ *
+ * ```ts
+ * inject(DestroyRef).onDestroy(inject(KeepAwake).hold('recording'));
+ * ```
+ *
+ * Never a bare activate: a screen that holds the display on and never releases it is a phone that
+ * never sleeps, which the user experiences as a battery fault and never attributes to the app.
+ *
+ * Tags are how two screens can each hold it without either releasing the other's.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface NativeKeepAwake {
+    activate(tag: string): Promise<void>;
+    deactivate(tag: string): Promise<void>;
+}
+export declare class KeepAwake {
+    /** Overridden in a test to record a hold without keeping a screen on. */
+    static readonly SOURCE: InjectionToken<NativeKeepAwake | null>;
+    private readonly native;
+    private readonly held;
+    /** The tags currently holding the screen on, so a debug screen can say which. */
+    readonly holders: Signal<ReadonlySet<string>>;
+    /** Whether anything currently holds the screen on. */
+    readonly active: Signal<boolean>;
+    /**
+     * Hold the screen on. Returns the function that releases it, ready for `DestroyRef.onDestroy`.
+     *
+     * Never a bare `activate()`, because the release is the half that gets forgotten and the half
+     * that matters.
+     */
+    hold(tag?: string): () => void;
+    /** How many holds each tag has that are not yet released. */
+    private readonly counts;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeepAwake, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/dist/keep-awake.js

@@ -0,0 +1,80 @@
+/**
+ * `KeepAwake`, bound to `expo-keep-awake`.
+ *
+ * ```ts
+ * inject(DestroyRef).onDestroy(inject(KeepAwake).hold('recording'));
+ * ```
+ *
+ * Never a bare activate: a screen that holds the display on and never releases it is a phone that
+ * never sleeps, which the user experiences as a battery fault and never attributes to the app.
+ *
+ * Tags are how two screens can each hold it without either releasing the other's.
+ */
+import { InjectionToken, Service, computed, inject, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+const DEFAULT_TAG = 'angular-native';
+export class KeepAwake {
+    /** Overridden in a test to record a hold without keeping a screen on. */
+    static SOURCE = new InjectionToken('angular-native.keepAwakeSource', {
+        factory: () => {
+            const expo = expoModule('expo-keep-awake', () => require('expo-keep-awake'));
+            if (!expo)
+                return null;
+            return {
+                activate: (tag) => expo.activateKeepAwakeAsync(tag),
+                deactivate: (tag) => expo.deactivateKeepAwake(tag),
+            };
+        },
+    });
+    native = inject(KeepAwake.SOURCE);
+    held = signal(new Set(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "held" }] : /* istanbul ignore next */ []));
+    /** The tags currently holding the screen on, so a debug screen can say which. */
+    holders = this.held.asReadonly();
+    /** Whether anything currently holds the screen on. */
+    active = computed(() => this.held().size > 0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "active" }] : /* istanbul ignore next */ []));
+    /**
+     * Hold the screen on. Returns the function that releases it, ready for `DestroyRef.onDestroy`.
+     *
+     * Never a bare `activate()`, because the release is the half that gets forgotten and the half
+     * that matters.
+     */
+    hold(tag = DEFAULT_TAG) {
+        // Counted per tag: two screens of one kind hold the same one, and the native module keeps a
+        // set of tags, so the first to release would otherwise let go for both.
+        const count = this.counts.get(tag) ?? 0;
+        this.counts.set(tag, count + 1);
+        if (count === 0) {
+            this.held.update((tags) => new Set(tags).add(tag));
+            void this.native?.activate(tag).catch(() => { });
+        }
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const left = (this.counts.get(tag) ?? 1) - 1;
+            if (left > 0) {
+                this.counts.set(tag, left);
+                return;
+            }
+            this.counts.delete(tag);
+            this.held.update((tags) => {
+                const next = new Set(tags);
+                next.delete(tag);
+                return next;
+            });
+            void this.native?.deactivate(tag).catch(() => { });
+        };
+    }
+    /** How many holds each tag has that are not yet released. */
+    counts = new Map();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: KeepAwake, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: KeepAwake });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: KeepAwake, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=keep-awake.js.map

package/dist/keep-awake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keep-awake.js","sourceRoot":"","sources":["../src/keep-awake.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `KeepAwake`, bound to `expo-keep-awake`.\n *\n * ```ts\n * inject(DestroyRef).onDestroy(inject(KeepAwake).hold('recording'));\n * ```\n *\n * Never a bare activate: a screen that holds the display on and never releases it is a phone that\n * never sleeps, which the user experiences as a battery fault and never attributes to the app.\n *\n * Tags are how two screens can each hold it without either releasing the other's.\n */\nimport { InjectionToken, Service, computed, inject, signal, type Signal } from '@angular/core';\nimport { expoModule } from './native.ts';\n\nexport interface NativeKeepAwake {\n  activate(tag: string): Promise<void>;\n  deactivate(tag: string): Promise<void>;\n}\n\nconst DEFAULT_TAG = 'angular-native';\n\n@Service()\nexport class KeepAwake {\n  /** Overridden in a test to record a hold without keeping a screen on. */\n  static readonly SOURCE = new InjectionToken<NativeKeepAwake | null>(\n    'angular-native.keepAwakeSource',\n    {\n      factory: () => {\n        const expo = expoModule(\n          'expo-keep-awake',\n          () => require('expo-keep-awake') as typeof import('expo-keep-awake'),\n        );\n        if (!expo) return null;\n        return {\n          activate: (tag) => expo.activateKeepAwakeAsync(tag),\n          deactivate: (tag) => expo.deactivateKeepAwake(tag),\n        };\n      },\n    },\n  );\n\n  private readonly native = inject(KeepAwake.SOURCE);\n  private readonly held = signal<ReadonlySet<string>>(new Set());\n\n  /** The tags currently holding the screen on, so a debug screen can say which. */\n  readonly holders: Signal<ReadonlySet<string>> = this.held.asReadonly();\n\n  /** Whether anything currently holds the screen on. */\n  readonly active: Signal<boolean> = computed(() => this.held().size > 0);\n\n  /**\n   * Hold the screen on. Returns the function that releases it, ready for `DestroyRef.onDestroy`.\n   *\n   * Never a bare `activate()`, because the release is the half that gets forgotten and the half\n   * that matters.\n   */\n  hold(tag = DEFAULT_TAG): () => void {\n    // Counted per tag: two screens of one kind hold the same one, and the native module keeps a\n    // set of tags, so the first to release would otherwise let go for both.\n    const count = this.counts.get(tag) ?? 0;\n    this.counts.set(tag, count + 1);\n    if (count === 0) {\n      this.held.update((tags) => new Set(tags).add(tag));\n      void this.native?.activate(tag).catch(() => {});\n    }\n\n    let released = false;\n    return () => {\n      if (released) return;\n      released = true;\n      const left = (this.counts.get(tag) ?? 1) - 1;\n      if (left > 0) {\n        this.counts.set(tag, left);\n        return;\n      }\n      this.counts.delete(tag);\n      this.held.update((tags) => {\n        const next = new Set(tags);\n        next.delete(tag);\n        return next;\n      });\n      void this.native?.deactivate(tag).catch(() => {});\n    };\n  }\n\n  /** How many holds each tag has that are not yet released. */\n  private readonly counts = new Map<string, number>();\n}\n"]}

package/dist/language-model.d.ts

@@ -0,0 +1,129 @@
+/**
+ * `LanguageModel`, bound to `expo-local-llm`.
+ *
+ * The model the operating system already has: Apple's Foundation Models on iOS 26 with Apple
+ * Intelligence, Gemini Nano on the Android phones that ship it. Nothing is bundled and nothing is
+ * sent anywhere; the prompt and the answer stay on the device.
+ *
+ * ```ts
+ * private readonly model = inject(LanguageModel);
+ * protected readonly answer = signal<LanguageModelStream | null>(null);
+ * ask(prompt: string) { this.answer.set(this.model.stream(prompt)); }
+ * ```
+ *
+ * Every call is a conversation of its own: a session is made, asked once and released, so one
+ * prompt never sees the last one. The module runs one stream at a time, so starting a stream
+ * cancels the one before it.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * What `expo-local-llm` reports, plus `notInstalled` for an app without the module or a build
+ * without its native code (Expo Go, or installed without a rebuild).
+ *
+ * - `available`: ready to answer.
+ * - `notEligible`: this device or OS version cannot run it (before iOS 26, older iPhones, most
+ *   Android phones).
+ * - `notEnabled`: the device can, but Apple Intelligence is switched off in Settings.
+ * - `notReady`: the model is still being prepared by the system, usually downloading after
+ *   Apple Intelligence was switched on.
+ * - `downloadRequired` / `downloading`: Android, where the app asks for Gemini Nano with
+ *   `download()`.
+ * - `unknown`: the platform said something the module does not name.
+ */
+export type LanguageModelAvailability = 'available' | 'notEligible' | 'notEnabled' | 'notReady' | 'downloadRequired' | 'downloading' | 'unknown' | 'notInstalled';
+export interface GenerateOptions {
+    /** System instructions: who the model is and how it answers. Kept apart from the prompt. */
+    readonly instructions?: string;
+    readonly temperature?: number;
+    /** Capped at 256 on Android. */
+    readonly maxTokens?: number;
+    readonly topK?: number;
+}
+/** A structured answer's shape: `expo-local-llm`'s own schema, a field per property. */
+export type LanguageModelSchema = import('expo-local-llm').Schema;
+type SessionConfig = import('expo-local-llm').SessionConfig;
+/** The slice of an `expo-local-llm` session this needs, with its token event unwrapped. */
+export interface NativeLanguageSession {
+    respond(prompt: string): Promise<string>;
+    /** Resolves with the whole text, or the text so far when cancelled; rejects on failure. */
+    stream(prompt: string, onText: (textSoFar: string) => void): Promise<string>;
+    cancel(): Promise<void>;
+    release(): void;
+}
+/** The slice of `expo-local-llm` this needs. */
+export interface NativeLanguageModel {
+    availability(): string;
+    onAvailabilityChange(listener: (availability: string) => void): {
+        remove(): void;
+    };
+    onDownloadProgress(listener: (progress: number) => void): {
+        remove(): void;
+    };
+    download(): Promise<void>;
+    session(config: SessionConfig): NativeLanguageSession;
+}
+/** Why a call was refused before it reached the model. */
+export declare class LanguageModelUnavailableError extends Error {
+    readonly reason: Exclude<LanguageModelAvailability, 'available'>;
+    constructor(reason: Exclude<LanguageModelAvailability, 'available'>);
+}
+export type LanguageModelStreamStatus = 'streaming' | 'done' | 'cancelled' | 'failed';
+/** One streamed answer, as signals a template binds. */
+export interface LanguageModelStream {
+    /** The text so far; the whole answer once `status` is `done`. */
+    readonly text: Signal<string>;
+    readonly status: Signal<LanguageModelStreamStatus>;
+    /** The failure's message while `status` is `failed`, otherwise null. */
+    readonly error: Signal<string | null>;
+    /** The final text (the partial text if cancelled). Rejects if the stream fails. */
+    readonly result: Promise<string>;
+    /** Stop generating. The text so far is kept. Does nothing once the stream has ended. */
+    cancel(): void;
+}
+/**
+ * The availability and download listeners follow the model for the life of the app, and are
+ * removed when the app is destroyed.
+ */
+export declare class LanguageModel {
+    /** Overridden in a test to answer without a model. */
+    static readonly SOURCE: InjectionToken<NativeLanguageModel | null>;
+    private readonly native;
+    private readonly state;
+    private readonly progress;
+    private streaming;
+    /** Whether the model can answer, and if not, the platform's reason. */
+    readonly availability: Signal<LanguageModelAvailability>;
+    readonly available: Signal<boolean>;
+    /** Android's download of Gemini Nano, 0 to 1. Null until a download reports; iOS never does. */
+    readonly downloadProgress: Signal<number | null>;
+    constructor();
+    /**
+     * Ask the platform again. iOS announces a change when the app comes back to the front, which
+     * covers Apple Intelligence being switched on in Settings; it does not announce the model
+     * finishing its preparation while the app is open.
+     */
+    refresh(): LanguageModelAvailability;
+    /** Ask Android to fetch Gemini Nano. Does nothing on iOS, where the system manages the model. */
+    download(): Promise<void>;
+    /** The whole answer at once. Rejects with the platform's reason when the model is unavailable. */
+    generate(prompt: string, options?: GenerateOptions): Promise<string>;
+    /**
+     * An answer shaped by `schema`, parsed. iOS constrains the model's decoding to the schema, so
+     * the answer always fits it; Android only asks the model to follow it, so check what comes back.
+     */
+    generateObject<T = unknown>(prompt: string, schema: LanguageModelSchema, options?: GenerateOptions): Promise<T>;
+    /**
+     * The answer as it is written, into a signal. Cancels any stream still running, because the
+     * module runs one at a time. Never throws: an unavailable model is a stream that has already
+     * failed, with the reason as its error.
+     */
+    stream(prompt: string, options?: GenerateOptions): LanguageModelStream;
+    private once;
+    /** Re-reads rather than trusting the signal, which only moves when the platform announces it. */
+    private refuseUnlessAvailable;
+    private read;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageModel, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};

package/dist/language-model.js

@@ -0,0 +1,225 @@
+/**
+ * `LanguageModel`, bound to `expo-local-llm`.
+ *
+ * The model the operating system already has: Apple's Foundation Models on iOS 26 with Apple
+ * Intelligence, Gemini Nano on the Android phones that ship it. Nothing is bundled and nothing is
+ * sent anywhere; the prompt and the answer stay on the device.
+ *
+ * ```ts
+ * private readonly model = inject(LanguageModel);
+ * protected readonly answer = signal<LanguageModelStream | null>(null);
+ * ask(prompt: string) { this.answer.set(this.model.stream(prompt)); }
+ * ```
+ *
+ * Every call is a conversation of its own: a session is made, asked once and released, so one
+ * prompt never sees the last one. The module runs one stream at a time, so starting a stream
+ * cancels the one before it.
+ */
+import { DestroyRef, InjectionToken, Service, computed, inject, signal, } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+const REPORTED = new Set([
+    'available',
+    'notEligible',
+    'notEnabled',
+    'notReady',
+    'downloadRequired',
+    'downloading',
+    'unknown',
+]);
+/** Why a call was refused before it reached the model. */
+export class LanguageModelUnavailableError extends Error {
+    reason;
+    constructor(reason) {
+        super(`The on-device language model is unavailable: ${reason}`);
+        this.name = 'LanguageModelUnavailableError';
+        this.reason = reason;
+    }
+}
+/**
+ * The availability and download listeners follow the model for the life of the app, and are
+ * removed when the app is destroyed.
+ */
+export class LanguageModel {
+    /** Overridden in a test to answer without a model. */
+    static SOURCE = new InjectionToken('angular-native.languageModelSource', {
+        factory: () => {
+            // The package loads without its native half, so that half is what decides.
+            const llm = expoModule('expo-local-llm', () => {
+                const loaded = require('expo-local-llm');
+                return loaded.ExpoLocalLlmModule ? loaded : null;
+            }, ['ios']);
+            const module = llm?.ExpoLocalLlmModule;
+            if (!llm || !module)
+                return null;
+            return {
+                availability: () => module.getAvailability(),
+                onAvailabilityChange: (listener) => module.addListener('availabilityChange', (event) => listener(event.availability)),
+                onDownloadProgress: (listener) => module.addListener('downloadProgress', (event) => listener(event.progress)),
+                download: () => module.downloadModel(),
+                session: (config) => {
+                    const session = llm.createLLMSession(config);
+                    return {
+                        respond: (prompt) => session.respond(prompt),
+                        stream: async (prompt, onText) => {
+                            const tokens = session.addListener('token', (event) => onText(event.accumulated));
+                            try {
+                                return await session.streamResponse(prompt);
+                            }
+                            finally {
+                                tokens.remove();
+                            }
+                        },
+                        cancel: () => session.cancelStream(),
+                        release: () => session.release(),
+                    };
+                },
+            };
+        },
+    });
+    native = inject(LanguageModel.SOURCE);
+    state = signal(this.read(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    progress = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "progress" }] : /* istanbul ignore next */ []));
+    streaming = null;
+    /** Whether the model can answer, and if not, the platform's reason. */
+    availability = this.state.asReadonly();
+    available = computed(() => this.state() === 'available', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "available" }] : /* istanbul ignore next */ []));
+    /** Android's download of Gemini Nano, 0 to 1. Null until a download reports; iOS never does. */
+    downloadProgress = this.progress.asReadonly();
+    constructor() {
+        const native = this.native;
+        if (!native)
+            return;
+        const availability = native.onAvailabilityChange((value) => this.state.set(known(value)));
+        const progress = native.onDownloadProgress((value) => this.progress.set(value));
+        inject(DestroyRef).onDestroy(() => {
+            availability.remove();
+            progress.remove();
+        });
+    }
+    /**
+     * Ask the platform again. iOS announces a change when the app comes back to the front, which
+     * covers Apple Intelligence being switched on in Settings; it does not announce the model
+     * finishing its preparation while the app is open.
+     */
+    refresh() {
+        this.state.set(this.read());
+        return this.state();
+    }
+    /** Ask Android to fetch Gemini Nano. Does nothing on iOS, where the system manages the model. */
+    async download() {
+        await this.native?.download();
+    }
+    /** The whole answer at once. Rejects with the platform's reason when the model is unavailable. */
+    async generate(prompt, options = {}) {
+        return this.once(config(options), prompt);
+    }
+    /**
+     * An answer shaped by `schema`, parsed. iOS constrains the model's decoding to the schema, so
+     * the answer always fits it; Android only asks the model to follow it, so check what comes back.
+     */
+    async generateObject(prompt, schema, options = {}) {
+        const text = await this.once({ ...config(options), responseFormat: 'json', schema }, prompt);
+        return JSON.parse(text);
+    }
+    /**
+     * The answer as it is written, into a signal. Cancels any stream still running, because the
+     * module runs one at a time. Never throws: an unavailable model is a stream that has already
+     * failed, with the reason as its error.
+     */
+    stream(prompt, options = {}) {
+        this.streaming?.cancel();
+        const text = signal('', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "text" }] : /* istanbul ignore next */ []));
+        const status = signal('streaming', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+        const error = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+        let session = null;
+        let cancelled = false;
+        const fail = (failure) => {
+            status.set('failed');
+            error.set(failure instanceof Error ? failure.message : String(failure));
+            throw failure;
+        };
+        let result;
+        try {
+            this.refuseUnlessAvailable();
+            const running = this.native.session(config(options));
+            session = running;
+            result = running
+                .stream(prompt, (soFar) => text.set(soFar))
+                .then((final) => {
+                text.set(final);
+                status.set(cancelled ? 'cancelled' : 'done');
+                return final;
+            }, fail)
+                .finally(() => running.release());
+        }
+        catch (refusal) {
+            result = Promise.reject(refusal);
+            try {
+                fail(refusal);
+            }
+            catch {
+                // Recorded on the signals at once, so a template shows the reason on its first render.
+            }
+        }
+        // Handled here so a stream whose result nobody awaits is not an unhandled rejection; anyone
+        // who does await it still sees the failure.
+        result.catch(() => { });
+        const stream = {
+            text: text.asReadonly(),
+            status: status.asReadonly(),
+            error: error.asReadonly(),
+            result,
+            cancel: () => {
+                if (status() !== 'streaming' || !session)
+                    return;
+                cancelled = true;
+                void session.cancel();
+            },
+        };
+        this.streaming = session ? stream : null;
+        return stream;
+    }
+    async once(sessionConfig, prompt) {
+        this.refuseUnlessAvailable();
+        const session = this.native.session(sessionConfig);
+        try {
+            return await session.respond(prompt);
+        }
+        finally {
+            session.release();
+        }
+    }
+    /** Re-reads rather than trusting the signal, which only moves when the platform announces it. */
+    refuseUnlessAvailable() {
+        const availability = this.refresh();
+        if (availability !== 'available')
+            throw new LanguageModelUnavailableError(availability);
+    }
+    read() {
+        return this.native ? known(this.native.availability()) : 'notInstalled';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: LanguageModel, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: LanguageModel });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: LanguageModel, decorators: [{
+            type: Service
+        }], ctorParameters: () => [] });
+function known(value) {
+    return REPORTED.has(value) ? value : 'unknown';
+}
+/** Only the keys that were given, so the native side sees its own defaults for the rest. */
+function config({ instructions, ...sampling }) {
+    const options = Object.fromEntries(Object.entries(sampling).filter(([, value]) => value !== undefined));
+    return {
+        ...(instructions === undefined ? {} : { instructions }),
+        ...(Object.keys(options).length === 0 ? {} : { options }),
+    };
+}
+//# sourceMappingURL=language-model.js.map