@ng-native/expo 0.0.1 → 0.1.1

package/dist/screen-capture.js

@@ -0,0 +1,78 @@
+/**
+ * `ScreenCapture`, bound to `expo-screen-capture`: keeping a screen out of screenshots and
+ * recordings, and knowing when one was taken.
+ *
+ * ```ts
+ * private readonly capture = inject(ScreenCapture);
+ *
+ * constructor() {
+ *   void this.capture.prevent('card-details');
+ *   inject(DestroyRef).onDestroy(() => void this.capture.allow('card-details'));
+ * }
+ * ```
+ *
+ * `prevent()` and `allow()` take a key, and capture stays prevented while any key is still held:
+ * two screens that each prevent it do not undo each other. `screenshots` counts the screenshots
+ * the user has taken, and the listener behind it lives as long as the app does and is removed
+ * when the app is destroyed. Without the module installed, nothing is prevented and the count
+ * stays at zero.
+ */
+import { DestroyRef, InjectionToken, Service, inject, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+import { Permission } from "./permissions.js";
+import * as i0 from "@angular/core";
+/** The permission answer without the module: nothing granted, and nothing to ask. */
+const UNAVAILABLE = { status: 'denied', granted: false, canAskAgain: false };
+export class ScreenCapture {
+    /** Overridden in a test to take screenshots nobody took. */
+    static SOURCE = new InjectionToken('angular-native.screenCaptureSource', {
+        factory: () => expoModule('expo-screen-capture', () => require('expo-screen-capture')),
+    });
+    native = inject(ScreenCapture.SOURCE);
+    count = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "count" }] : /* istanbul ignore next */ []));
+    /**
+     * The permission screenshot detection needs on Android 13 and earlier, where it reads the
+     * photo library. Later Android needs none, and iOS always answers granted.
+     */
+    permission = Permission.of(() => this.native?.getPermissionsAsync() ?? Promise.resolve(UNAVAILABLE), () => this.native?.requestPermissionsAsync() ?? Promise.resolve(UNAVAILABLE));
+    /** How many screenshots the user has taken while the app was in front. */
+    screenshots = this.count.asReadonly();
+    constructor() {
+        const listener = this.native?.addScreenshotListener(() => this.count.update((n) => n + 1));
+        if (listener)
+            inject(DestroyRef).onDestroy(() => listener.remove());
+    }
+    /** Whether the platform can prevent capture. */
+    async available() {
+        return (await this.native?.isAvailableAsync()) ?? false;
+    }
+    /**
+     * Keeps the app out of screenshots and screen recordings until `allow()` is called with the same
+     * key, or the app restarts. Omitting the key uses one shared default key.
+     */
+    async prevent(key) {
+        await this.native?.preventScreenCaptureAsync(key);
+    }
+    /** Releases the key; capture is allowed again once no key is held. */
+    async allow(key) {
+        await this.native?.allowScreenCaptureAsync(key);
+    }
+    /**
+     * iOS: blurs the app while it is not in focus - in the app switcher, in the background, and
+     * during interruptions - by `blurIntensity` from 0 to 1, half by default. Android already hides
+     * it in the app switcher while capture is prevented.
+     */
+    async protectAppSwitcher(blurIntensity) {
+        await this.native?.enableAppSwitcherProtectionAsync(blurIntensity);
+    }
+    async unprotectAppSwitcher() {
+        await this.native?.disableAppSwitcherProtectionAsync();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ScreenCapture, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: ScreenCapture });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ScreenCapture, decorators: [{
+            type: Service
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=screen-capture.js.map

package/dist/screen-capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-capture.js","sourceRoot":"","sources":["../src/screen-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AACjG,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,UAAU,EAA2B,MAAM,kBAAkB,CAAC;;AAiBvE,qFAAqF;AACrF,MAAM,WAAW,GAAuB,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;AAGjG,MAAM,OAAO,aAAa;IACxB,4DAA4D;IAC5D,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,oCAAoC,EACpC;QACE,OAAO,EAAE,GAAG,EAAE,CACZ,UAAU,CAAC,qBAAqB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,qBAAqB,CAAS,CAAC;KAClF,CACF,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,KAAK,GAAG,MAAM,CAAC,CAAC;8EAAC,CAAC;IAEnC;;;OAGG;IACM,UAAU,GAAe,UAAU,CAAC,EAAE,CAC7C,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,EACxE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,uBAAuB,EAAE,IAAI,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAC7E,CAAC;IAEF,0EAA0E;IACjE,WAAW,GAAmB,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;IAE/D;QACE,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC3F,IAAI,QAAQ;YAAE,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,gDAAgD;IAChD,KAAK,CAAC,SAAS;QACb,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,IAAI,KAAK,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO,CAAC,GAAY;QACxB,MAAM,IAAI,CAAC,MAAM,EAAE,yBAAyB,CAAC,GAAG,CAAC,CAAC;IACpD,CAAC;IAED,sEAAsE;IACtE,KAAK,CAAC,KAAK,CAAC,GAAY;QACtB,MAAM,IAAI,CAAC,MAAM,EAAE,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,kBAAkB,CAAC,aAAsB;QAC7C,MAAM,IAAI,CAAC,MAAM,EAAE,gCAAgC,CAAC,aAAa,CAAC,CAAC;IACrE,CAAC;IAED,KAAK,CAAC,oBAAoB;QACxB,MAAM,IAAI,CAAC,MAAM,EAAE,iCAAiC,EAAE,CAAC;IACzD,CAAC;uGA3DU,aAAa;wGAAb,aAAa;;2FAAb,aAAa;kBADzB,OAAO","sourcesContent":["/**\n * `ScreenCapture`, bound to `expo-screen-capture`: keeping a screen out of screenshots and\n * recordings, and knowing when one was taken.\n *\n * ```ts\n * private readonly capture = inject(ScreenCapture);\n *\n * constructor() {\n *   void this.capture.prevent('card-details');\n *   inject(DestroyRef).onDestroy(() => void this.capture.allow('card-details'));\n * }\n * ```\n *\n * `prevent()` and `allow()` take a key, and capture stays prevented while any key is still held:\n * two screens that each prevent it do not undo each other. `screenshots` counts the screenshots\n * the user has taken, and the listener behind it lives as long as the app does and is removed\n * when the app is destroyed. Without the module installed, nothing is prevented and the count\n * stays at zero.\n */\nimport { DestroyRef, InjectionToken, Service, inject, signal, type Signal } from '@angular/core';\nimport { expoModule } from './native.ts';\nimport { Permission, type PermissionResponse } from './permissions.ts';\n\ntype Expo = typeof import('expo-screen-capture');\n\n/** The module's functions this service calls. The real module is one; a test provides a fake. */\nexport type NativeScreenCapture = Pick<\n  Expo,\n  | 'isAvailableAsync'\n  | 'preventScreenCaptureAsync'\n  | 'allowScreenCaptureAsync'\n  | 'enableAppSwitcherProtectionAsync'\n  | 'disableAppSwitcherProtectionAsync'\n  | 'addScreenshotListener'\n  | 'getPermissionsAsync'\n  | 'requestPermissionsAsync'\n>;\n\n/** The permission answer without the module: nothing granted, and nothing to ask. */\nconst UNAVAILABLE: PermissionResponse = { status: 'denied', granted: false, canAskAgain: false };\n\n@Service()\nexport class ScreenCapture {\n  /** Overridden in a test to take screenshots nobody took. */\n  static readonly SOURCE = new InjectionToken<NativeScreenCapture | null>(\n    'angular-native.screenCaptureSource',\n    {\n      factory: () =>\n        expoModule('expo-screen-capture', () => require('expo-screen-capture') as Expo),\n    },\n  );\n\n  private readonly native = inject(ScreenCapture.SOURCE);\n  private readonly count = signal(0);\n\n  /**\n   * The permission screenshot detection needs on Android 13 and earlier, where it reads the\n   * photo library. Later Android needs none, and iOS always answers granted.\n   */\n  readonly permission: Permission = Permission.of(\n    () => this.native?.getPermissionsAsync() ?? Promise.resolve(UNAVAILABLE),\n    () => this.native?.requestPermissionsAsync() ?? Promise.resolve(UNAVAILABLE),\n  );\n\n  /** How many screenshots the user has taken while the app was in front. */\n  readonly screenshots: Signal<number> = this.count.asReadonly();\n\n  constructor() {\n    const listener = this.native?.addScreenshotListener(() => this.count.update((n) => n + 1));\n    if (listener) inject(DestroyRef).onDestroy(() => listener.remove());\n  }\n\n  /** Whether the platform can prevent capture. */\n  async available(): Promise<boolean> {\n    return (await this.native?.isAvailableAsync()) ?? false;\n  }\n\n  /**\n   * Keeps the app out of screenshots and screen recordings until `allow()` is called with the same\n   * key, or the app restarts. Omitting the key uses one shared default key.\n   */\n  async prevent(key?: string): Promise<void> {\n    await this.native?.preventScreenCaptureAsync(key);\n  }\n\n  /** Releases the key; capture is allowed again once no key is held. */\n  async allow(key?: string): Promise<void> {\n    await this.native?.allowScreenCaptureAsync(key);\n  }\n\n  /**\n   * iOS: blurs the app while it is not in focus - in the app switcher, in the background, and\n   * during interruptions - by `blurIntensity` from 0 to 1, half by default. Android already hides\n   * it in the app switcher while capture is prevented.\n   */\n  async protectAppSwitcher(blurIntensity?: number): Promise<void> {\n    await this.native?.enableAppSwitcherProtectionAsync(blurIntensity);\n  }\n\n  async unprotectAppSwitcher(): Promise<void> {\n    await this.native?.disableAppSwitcherProtectionAsync();\n  }\n}\n"]}

package/dist/segmented-control.d.ts

@@ -0,0 +1,32 @@
+import type { NativeSyntheticEvent } from '@ng-native/fabric';
+import * as i0 from "@angular/core";
+/** The font the segments' titles are drawn in. */
+export interface SegmentedControlFont {
+    readonly color?: string;
+    readonly fontSize?: number;
+    readonly fontFamily?: string;
+    readonly fontWeight?: string;
+}
+/** What the control sends when the user picks a segment. */
+export type SegmentedControlChangeEvent = NativeSyntheticEvent<{
+    readonly value: string;
+    readonly selectedSegmentIndex: number;
+}>;
+export declare class SegmentedControl {
+    readonly values: import("@angular/core").InputSignal<readonly string[] | undefined>;
+    readonly selectedIndex: import("@angular/core").InputSignalWithTransform<number | undefined, unknown>;
+    readonly enabled: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Segments do not stay selected: each is a button. */
+    readonly momentary: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** The selected segment's colour. */
+    readonly tintColor: import("@angular/core").InputSignal<string | undefined>;
+    readonly backgroundColor: import("@angular/core").InputSignal<string | undefined>;
+    readonly fontStyle: import("@angular/core").InputSignal<SegmentedControlFont | undefined>;
+    readonly activeFontStyle: import("@angular/core").InputSignal<SegmentedControlFont | undefined>;
+    /** Each segment as wide as its title rather than all equal. */
+    readonly apportionsSegmentWidthsByContent: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly accessibilityLabel: import("@angular/core").InputSignal<string | undefined>;
+    readonly change: import("@angular/core").OutputEmitterRef<SegmentedControlChangeEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedControl, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentedControl, "segmented-control", never, { "values": { "alias": "values"; "required": false; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "momentary": { "alias": "momentary"; "required": false; "isSignal": true; }; "tintColor": { "alias": "tintColor"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "fontStyle": { "alias": "fontStyle"; "required": false; "isSignal": true; }; "activeFontStyle": { "alias": "activeFontStyle"; "required": false; "isSignal": true; }; "apportionsSegmentWidthsByContent": { "alias": "apportionsSegmentWidthsByContent"; "required": false; "isSignal": true; }; "accessibilityLabel": { "alias": "accessibilityLabel"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, never, true, never>;
+}

package/dist/segmented-control.js

@@ -0,0 +1,55 @@
+/**
+ * `<segmented-control>` with its props and its `change` event typed.
+ *
+ * The element is `NATIVE_VIEWS`' name for `@react-native-segmented-control/segmented-control`; this
+ * only claims it so strict templates know its props. Each input goes straight to the node, and
+ * `change` is an output for its type only: the element's own event is what arrives, as with the
+ * `@expo/ui` components in `expo-ui-components.ts`.
+ */
+import { Component, input, output } from '@angular/core';
+import { optionalBoolean, optionalNumber } from "./transforms.js";
+import * as i0 from "@angular/core";
+export class SegmentedControl {
+    values = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "values" }] : /* istanbul ignore next */ []));
+    selectedIndex = input(undefined, { ...(ngDevMode ? { debugName: "selectedIndex" } : /* istanbul ignore next */ {}), transform: optionalNumber });
+    enabled = input(undefined, { ...(ngDevMode ? { debugName: "enabled" } : /* istanbul ignore next */ {}), transform: optionalBoolean });
+    /** Segments do not stay selected: each is a button. */
+    momentary = input(undefined, { ...(ngDevMode ? { debugName: "momentary" } : /* istanbul ignore next */ {}), transform: optionalBoolean });
+    /** The selected segment's colour. */
+    tintColor = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "tintColor" }] : /* istanbul ignore next */ []));
+    backgroundColor = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "backgroundColor" }] : /* istanbul ignore next */ []));
+    fontStyle = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "fontStyle" }] : /* istanbul ignore next */ []));
+    activeFontStyle = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "activeFontStyle" }] : /* istanbul ignore next */ []));
+    /** Each segment as wide as its title rather than all equal. */
+    apportionsSegmentWidthsByContent = input(undefined, { ...(ngDevMode ? { debugName: "apportionsSegmentWidthsByContent" } : /* istanbul ignore next */ {}), transform: optionalBoolean });
+    accessibilityLabel = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "accessibilityLabel" }] : /* istanbul ignore next */ []));
+    change = output();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: SegmentedControl, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.2.0", type: SegmentedControl, isStandalone: true, selector: "segmented-control", inputs: { values: { classPropertyName: "values", publicName: "values", isSignal: true, isRequired: false, transformFunction: null }, selectedIndex: { classPropertyName: "selectedIndex", publicName: "selectedIndex", isSignal: true, isRequired: false, transformFunction: null }, enabled: { classPropertyName: "enabled", publicName: "enabled", isSignal: true, isRequired: false, transformFunction: null }, momentary: { classPropertyName: "momentary", publicName: "momentary", isSignal: true, isRequired: false, transformFunction: null }, tintColor: { classPropertyName: "tintColor", publicName: "tintColor", isSignal: true, isRequired: false, transformFunction: null }, backgroundColor: { classPropertyName: "backgroundColor", publicName: "backgroundColor", isSignal: true, isRequired: false, transformFunction: null }, fontStyle: { classPropertyName: "fontStyle", publicName: "fontStyle", isSignal: true, isRequired: false, transformFunction: null }, activeFontStyle: { classPropertyName: "activeFontStyle", publicName: "activeFontStyle", isSignal: true, isRequired: false, transformFunction: null }, apportionsSegmentWidthsByContent: { classPropertyName: "apportionsSegmentWidthsByContent", publicName: "apportionsSegmentWidthsByContent", isSignal: true, isRequired: false, transformFunction: null }, accessibilityLabel: { classPropertyName: "accessibilityLabel", publicName: "accessibilityLabel", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { change: "change" }, host: { properties: { "values": "values()", "selectedIndex": "selectedIndex()", "enabled": "enabled()", "momentary": "momentary()", "tintColor": "tintColor()", "backgroundColor": "backgroundColor()", "fontStyle": "fontStyle()", "activeFontStyle": "activeFontStyle()", "apportionsSegmentWidthsByContent": "apportionsSegmentWidthsByContent()", "accessibilityLabel": "accessibilityLabel()" } }, ngImport: i0, template: '', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: SegmentedControl, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'segmented-control',
+                    template: '',
+                    host: {
+                        '[values]': 'values()',
+                        '[selectedIndex]': 'selectedIndex()',
+                        '[enabled]': 'enabled()',
+                        '[momentary]': 'momentary()',
+                        '[tintColor]': 'tintColor()',
+                        '[backgroundColor]': 'backgroundColor()',
+                        '[fontStyle]': 'fontStyle()',
+                        '[activeFontStyle]': 'activeFontStyle()',
+                        '[apportionsSegmentWidthsByContent]': 'apportionsSegmentWidthsByContent()',
+                        '[accessibilityLabel]': 'accessibilityLabel()',
+                    },
+                }]
+        }], propDecorators: { values: [{ type: i0.Input, args: [{ isSignal: true, alias: "values", required: false }] }], selectedIndex: [{ type: i0.Input, args: [{ isSignal: true, alias: "selectedIndex", required: false }] }], enabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "enabled", required: false }] }], momentary: [{ type: i0.Input, args: [{ isSignal: true, alias: "momentary", required: false }] }], tintColor: [{ type: i0.Input, args: [{ isSignal: true, alias: "tintColor", required: false }] }], backgroundColor: [{ type: i0.Input, args: [{ isSignal: true, alias: "backgroundColor", required: false }] }], fontStyle: [{ type: i0.Input, args: [{ isSignal: true, alias: "fontStyle", required: false }] }], activeFontStyle: [{ type: i0.Input, args: [{ isSignal: true, alias: "activeFontStyle", required: false }] }], apportionsSegmentWidthsByContent: [{ type: i0.Input, args: [{ isSignal: true, alias: "apportionsSegmentWidthsByContent", required: false }] }], accessibilityLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "accessibilityLabel", required: false }] }], change: [{ type: i0.Output, args: ["change"] }] } });
+//# sourceMappingURL=segmented-control.js.map

package/dist/segmented-control.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmented-control.js","sourceRoot":"","sources":["../src/segmented-control.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;;AAgClE,MAAM,OAAO,gBAAgB;IAClB,MAAM,GAAG,KAAK;0FAAqB,CAAC;IACpC,aAAa,GAAG,KAAK,CAAS,SAAS,qFAAI,SAAS,EAAE,cAAc,GAAG,CAAC;IACxE,OAAO,GAAG,KAAK,CAAU,SAAS,+EAAI,SAAS,EAAE,eAAe,GAAG,CAAC;IAC7E,uDAAuD;IAC9C,SAAS,GAAG,KAAK,CAAU,SAAS,iFAAI,SAAS,EAAE,eAAe,GAAG,CAAC;IAC/E,qCAAqC;IAC5B,SAAS,GAAG,KAAK;6FAAU,CAAC;IAC5B,eAAe,GAAG,KAAK;mGAAU,CAAC;IAClC,SAAS,GAAG,KAAK;6FAAwB,CAAC;IAC1C,eAAe,GAAG,KAAK;mGAAwB,CAAC;IACzD,+DAA+D;IACtD,gCAAgC,GAAG,KAAK,CAAU,SAAS,wGAClE,SAAS,EAAE,eAAe,GAC1B,CAAC;IACM,kBAAkB,GAAG,KAAK;sGAAU,CAAC;IACrC,MAAM,GAAG,MAAM,EAA+B,CAAC;uGAhB7C,gBAAgB;2FAAhB,gBAAgB,y6DAdjB,EAAE;;2FAcD,gBAAgB;kBAhB5B,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,QAAQ,EAAE,EAAE;oBACZ,IAAI,EAAE;wBACJ,UAAU,EAAE,UAAU;wBACtB,iBAAiB,EAAE,iBAAiB;wBACpC,WAAW,EAAE,WAAW;wBACxB,aAAa,EAAE,aAAa;wBAC5B,aAAa,EAAE,aAAa;wBAC5B,mBAAmB,EAAE,mBAAmB;wBACxC,aAAa,EAAE,aAAa;wBAC5B,mBAAmB,EAAE,mBAAmB;wBACxC,oCAAoC,EAAE,oCAAoC;wBAC1E,sBAAsB,EAAE,sBAAsB;qBAC/C;iBACF","sourcesContent":["/**\n * `<segmented-control>` with its props and its `change` event typed.\n *\n * The element is `NATIVE_VIEWS`' name for `@react-native-segmented-control/segmented-control`; this\n * only claims it so strict templates know its props. Each input goes straight to the node, and\n * `change` is an output for its type only: the element's own event is what arrives, as with the\n * `@expo/ui` components in `expo-ui-components.ts`.\n */\nimport { Component, input, output } from '@angular/core';\nimport type { NativeSyntheticEvent } from '@ng-native/fabric';\nimport { optionalBoolean, optionalNumber } from './transforms.ts';\n\n/** The font the segments' titles are drawn in. */\nexport interface SegmentedControlFont {\n  readonly color?: string;\n  readonly fontSize?: number;\n  readonly fontFamily?: string;\n  readonly fontWeight?: string;\n}\n\n/** What the control sends when the user picks a segment. */\nexport type SegmentedControlChangeEvent = NativeSyntheticEvent<{\n  readonly value: string;\n  readonly selectedSegmentIndex: number;\n}>;\n\n@Component({\n  selector: 'segmented-control',\n  template: '',\n  host: {\n    '[values]': 'values()',\n    '[selectedIndex]': 'selectedIndex()',\n    '[enabled]': 'enabled()',\n    '[momentary]': 'momentary()',\n    '[tintColor]': 'tintColor()',\n    '[backgroundColor]': 'backgroundColor()',\n    '[fontStyle]': 'fontStyle()',\n    '[activeFontStyle]': 'activeFontStyle()',\n    '[apportionsSegmentWidthsByContent]': 'apportionsSegmentWidthsByContent()',\n    '[accessibilityLabel]': 'accessibilityLabel()',\n  },\n})\nexport class SegmentedControl {\n  readonly values = input<readonly string[]>();\n  readonly selectedIndex = input<number>(undefined, { transform: optionalNumber });\n  readonly enabled = input<boolean>(undefined, { transform: optionalBoolean });\n  /** Segments do not stay selected: each is a button. */\n  readonly momentary = input<boolean>(undefined, { transform: optionalBoolean });\n  /** The selected segment's colour. */\n  readonly tintColor = input<string>();\n  readonly backgroundColor = input<string>();\n  readonly fontStyle = input<SegmentedControlFont>();\n  readonly activeFontStyle = input<SegmentedControlFont>();\n  /** Each segment as wide as its title rather than all equal. */\n  readonly apportionsSegmentWidthsByContent = input<boolean>(undefined, {\n    transform: optionalBoolean,\n  });\n  readonly accessibilityLabel = input<string>();\n  readonly change = output<SegmentedControlChangeEvent>();\n}\n"]}

package/dist/sensors.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The motion sensors, bound to `expo-sensors`.
+ *
+ * ```ts
+ * private readonly motion = inject(Accelerometer);
+ *
+ * constructor() {
+ *   inject(DestroyRef).onDestroy(this.motion.start(50));
+ * }
+ * ```
+ *
+ * Every one of them is the same object - `addListener`, `setUpdateInterval`, `isAvailableAsync` -
+ * so this is one class parameterised by the reading, not one per sensor. Six services sharing one
+ * class is why these are tokens rather than six decorated classes: a `@Service` class cannot be
+ * generic in the thing it reports.
+ *
+ * Nothing is subscribed until `start`, and the interval is explicit: the sensible one is a
+ * property of what the app is doing - a compass wants a tenth of a second, a shake detector less -
+ * and every event is a change-detection pass, so a sensor left at its default is a phone that
+ * never idles.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+/** What a three-axis sensor reports. Barometer and light report their own shapes. */
+export interface Vector {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+export interface NativeSensor<T> {
+    addListener(listener: (reading: T) => void): {
+        remove(): void;
+    };
+    setUpdateInterval(intervalMs: number): void;
+    isAvailableAsync(): Promise<boolean>;
+}
+export declare class Sensor<T> {
+    private readonly native;
+    private readonly current;
+    private readonly present;
+    private subscription;
+    /** The most recent reading, or the stated zero until the sensor has said anything. */
+    readonly reading: Signal<T>;
+    /**
+     * Whether the device has this sensor. Null until the platform has answered, which is one turn
+     * away: `isAvailableAsync` is asynchronous even where the answer is a constant.
+     *
+     * A signal rather than the promise the module offers, because the question is asked in a
+     * template - `@if (barometer.available())` - and a promise there is truthy on the first frame
+     * and every frame after, which is the failure this project keeps guarding against.
+     */
+    readonly available: Signal<boolean | null>;
+    constructor(native: NativeSensor<T> | null, zero: T);
+    /**
+     * Start reading, at `intervalMs` between readings. Returns the function that stops.
+     *
+     * Explicit rather than automatic, because the sensible interval is a property of what the app is
+     * doing with it - a compass needs a tenth of a second and a shake detector needs less - and
+     * because a sensor nobody stops is a battery nobody gets back.
+     */
+    start(intervalMs?: number): () => void;
+    /** Every `start` not yet stopped. */
+    private readonly claims;
+    private fastest;
+    /** Stop reading for everyone who started it. */
+    stop(): void;
+}
+export declare const ORIGIN: Vector;
+/** In g. Includes gravity, so a phone lying flat reads about 1 on z. */
+export declare const Accelerometer: InjectionToken<Sensor<import("expo-sensors").AccelerometerMeasurement>>;
+export type Accelerometer = Sensor<import('expo-sensors').AccelerometerMeasurement>;
+/** Rotation, in radians per second. */
+export declare const Gyroscope: InjectionToken<Sensor<import("expo-sensors").GyroscopeMeasurement>>;
+export type Gyroscope = Sensor<import('expo-sensors').GyroscopeMeasurement>;
+/** The magnetic field, in microteslas. What a compass is built on. */
+export declare const Magnetometer: InjectionToken<Sensor<import("expo-sensors").MagnetometerMeasurement>>;
+export type Magnetometer = Sensor<import('expo-sensors').MagnetometerMeasurement>;
+/** Everything at once, plus the orientation and rotation rate derived from it. */
+export declare const DeviceMotion: InjectionToken<Sensor<import("expo-sensors").DeviceMotionMeasurement>>;
+export type DeviceMotion = Sensor<import('expo-sensors').DeviceMotionMeasurement>;
+/** Air pressure, in hectopascals. Present on fewer devices than the rest; check `available`. */
+export declare const Barometer: InjectionToken<Sensor<import("expo-sensors").BarometerMeasurement>>;
+export type Barometer = Sensor<import('expo-sensors').BarometerMeasurement>;
+/** Ambient light in lux. Android only. */
+export declare const LightSensor: InjectionToken<Sensor<import("expo-sensors").LightSensorMeasurement>>;
+export type LightSensor = Sensor<import('expo-sensors').LightSensorMeasurement>;

package/dist/sensors.js

@@ -0,0 +1,115 @@
+/**
+ * The motion sensors, bound to `expo-sensors`.
+ *
+ * ```ts
+ * private readonly motion = inject(Accelerometer);
+ *
+ * constructor() {
+ *   inject(DestroyRef).onDestroy(this.motion.start(50));
+ * }
+ * ```
+ *
+ * Every one of them is the same object - `addListener`, `setUpdateInterval`, `isAvailableAsync` -
+ * so this is one class parameterised by the reading, not one per sensor. Six services sharing one
+ * class is why these are tokens rather than six decorated classes: a `@Service` class cannot be
+ * generic in the thing it reports.
+ *
+ * Nothing is subscribed until `start`, and the interval is explicit: the sensible one is a
+ * property of what the app is doing - a compass wants a tenth of a second, a shake detector less -
+ * and every event is a change-detection pass, so a sensor left at its default is a phone that
+ * never idles.
+ */
+import { InjectionToken, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+export class Sensor {
+    native;
+    current;
+    present = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "present" }] : /* istanbul ignore next */ []));
+    subscription = null;
+    /** The most recent reading, or the stated zero until the sensor has said anything. */
+    reading;
+    /**
+     * Whether the device has this sensor. Null until the platform has answered, which is one turn
+     * away: `isAvailableAsync` is asynchronous even where the answer is a constant.
+     *
+     * A signal rather than the promise the module offers, because the question is asked in a
+     * template - `@if (barometer.available())` - and a promise there is truthy on the first frame
+     * and every frame after, which is the failure this project keeps guarding against.
+     */
+    available = this.present.asReadonly();
+    constructor(native, zero) {
+        this.native = native;
+        this.current = signal(zero, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "current" }] : /* istanbul ignore next */ []));
+        this.reading = this.current.asReadonly();
+        void (native?.isAvailableAsync() ?? Promise.resolve(false)).then((yes) => this.present.set(yes), () => this.present.set(false));
+    }
+    /**
+     * Start reading, at `intervalMs` between readings. Returns the function that stops.
+     *
+     * Explicit rather than automatic, because the sensible interval is a property of what the app is
+     * doing with it - a compass needs a tenth of a second and a shake detector needs less - and
+     * because a sensor nobody stops is a battery nobody gets back.
+     */
+    start(intervalMs = 100) {
+        // One sensor serves the whole app, so each start is a claim of its own, and its stop gives
+        // back that claim alone: the sensor reads while anyone still wants it, as often as the most
+        // demanding of them asks.
+        const claim = { intervalMs };
+        this.claims.add(claim);
+        this.native?.setUpdateInterval(this.fastest());
+        this.subscription ??= this.native?.addListener((reading) => this.current.set(reading)) ?? null;
+        return () => {
+            if (!this.claims.delete(claim))
+                return;
+            if (this.claims.size === 0)
+                this.stop();
+            else
+                this.native?.setUpdateInterval(this.fastest());
+        };
+    }
+    /** Every `start` not yet stopped. */
+    claims = new Set();
+    fastest() {
+        return Math.min(...[...this.claims].map((claim) => claim.intervalMs));
+    }
+    /** Stop reading for everyone who started it. */
+    stop() {
+        this.claims.clear();
+        this.subscription?.remove();
+        this.subscription = null;
+    }
+}
+export const ORIGIN = { x: 0, y: 0, z: 0 };
+/** Every reading carries the time it was taken, so the zero has to as well. */
+const STILL = { x: 0, y: 0, z: 0, timestamp: 0 };
+/** One token per sensor, each reading the module only if it is installed. */
+function sensorToken(pick, zero, name) {
+    return new InjectionToken(`angular-native.${name}`, {
+        factory: () => {
+            const expo = expoModule('expo-sensors', () => require('expo-sensors'));
+            return new Sensor(expo ? pick(expo) : null, zero);
+        },
+    });
+}
+/** In g. Includes gravity, so a phone lying flat reads about 1 on z. */
+export const Accelerometer = sensorToken((expo) => expo.Accelerometer, STILL, 'accelerometer');
+/** Rotation, in radians per second. */
+export const Gyroscope = sensorToken((expo) => expo.Gyroscope, STILL, 'gyroscope');
+/** The magnetic field, in microteslas. What a compass is built on. */
+export const Magnetometer = sensorToken((expo) => expo.Magnetometer, STILL, 'magnetometer');
+/** Everything at once, plus the orientation and rotation rate derived from it. */
+export const DeviceMotion = sensorToken((expo) => expo.DeviceMotion, {
+    acceleration: null,
+    accelerationIncludingGravity: STILL,
+    rotation: { alpha: 0, beta: 0, gamma: 0 },
+    rotationRate: null,
+    orientation: 0,
+    interval: 0,
+}, 'deviceMotion');
+/** Air pressure, in hectopascals. Present on fewer devices than the rest; check `available`. */
+export const Barometer = sensorToken((expo) => expo.Barometer, { pressure: 0, relativeAltitude: 0 }, 'barometer');
+/** Ambient light in lux. Android only. */
+export const LightSensor = sensorToken((expo) => expo.LightSensor, { illuminance: 0 }, 'lightSensor');
+//# sourceMappingURL=sensors.js.map

package/dist/sensors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sensors.js","sourceRoot":"","sources":["../src/sensors.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The motion sensors, bound to `expo-sensors`.\n *\n * ```ts\n * private readonly motion = inject(Accelerometer);\n *\n * constructor() {\n *   inject(DestroyRef).onDestroy(this.motion.start(50));\n * }\n * ```\n *\n * Every one of them is the same object - `addListener`, `setUpdateInterval`, `isAvailableAsync` -\n * so this is one class parameterised by the reading, not one per sensor. Six services sharing one\n * class is why these are tokens rather than six decorated classes: a `@Service` class cannot be\n * generic in the thing it reports.\n *\n * Nothing is subscribed until `start`, and the interval is explicit: the sensible one is a\n * property of what the app is doing - a compass wants a tenth of a second, a shake detector less -\n * and every event is a change-detection pass, so a sensor left at its default is a phone that\n * never idles.\n */\nimport { InjectionToken, signal, type Signal } from '@angular/core';\nimport { expoModule } from './native.ts';\n\n/** What a three-axis sensor reports. Barometer and light report their own shapes. */\nexport interface Vector {\n  readonly x: number;\n  readonly y: number;\n  readonly z: number;\n}\n\nexport interface NativeSensor<T> {\n  addListener(listener: (reading: T) => void): { remove(): void };\n  setUpdateInterval(intervalMs: number): void;\n  isAvailableAsync(): Promise<boolean>;\n}\n\nexport class Sensor<T> {\n  private readonly native: NativeSensor<T> | null;\n  private readonly current: ReturnType<typeof signal<T>>;\n  private readonly present = signal<boolean | null>(null);\n  private subscription: { remove(): void } | null = null;\n\n  /** The most recent reading, or the stated zero until the sensor has said anything. */\n  readonly reading: Signal<T>;\n\n  /**\n   * Whether the device has this sensor. Null until the platform has answered, which is one turn\n   * away: `isAvailableAsync` is asynchronous even where the answer is a constant.\n   *\n   * A signal rather than the promise the module offers, because the question is asked in a\n   * template - `@if (barometer.available())` - and a promise there is truthy on the first frame\n   * and every frame after, which is the failure this project keeps guarding against.\n   */\n  readonly available: Signal<boolean | null> = this.present.asReadonly();\n\n  constructor(native: NativeSensor<T> | null, zero: T) {\n    this.native = native;\n    this.current = signal(zero);\n    this.reading = this.current.asReadonly();\n    void (native?.isAvailableAsync() ?? Promise.resolve(false)).then(\n      (yes) => this.present.set(yes),\n      () => this.present.set(false),\n    );\n  }\n\n  /**\n   * Start reading, at `intervalMs` between readings. Returns the function that stops.\n   *\n   * Explicit rather than automatic, because the sensible interval is a property of what the app is\n   * doing with it - a compass needs a tenth of a second and a shake detector needs less - and\n   * because a sensor nobody stops is a battery nobody gets back.\n   */\n  start(intervalMs = 100): () => void {\n    // One sensor serves the whole app, so each start is a claim of its own, and its stop gives\n    // back that claim alone: the sensor reads while anyone still wants it, as often as the most\n    // demanding of them asks.\n    const claim = { intervalMs };\n    this.claims.add(claim);\n    this.native?.setUpdateInterval(this.fastest());\n    this.subscription ??= this.native?.addListener((reading) => this.current.set(reading)) ?? null;\n    return () => {\n      if (!this.claims.delete(claim)) return;\n      if (this.claims.size === 0) this.stop();\n      else this.native?.setUpdateInterval(this.fastest());\n    };\n  }\n\n  /** Every `start` not yet stopped. */\n  private readonly claims = new Set<{ readonly intervalMs: number }>();\n\n  private fastest(): number {\n    return Math.min(...[...this.claims].map((claim) => claim.intervalMs));\n  }\n\n  /** Stop reading for everyone who started it. */\n  stop(): void {\n    this.claims.clear();\n    this.subscription?.remove();\n    this.subscription = null;\n  }\n}\n\nexport const ORIGIN: Vector = { x: 0, y: 0, z: 0 };\n\n/** Every reading carries the time it was taken, so the zero has to as well. */\nconst STILL = { x: 0, y: 0, z: 0, timestamp: 0 };\n\ntype Sensors = typeof import('expo-sensors');\n\n/** One token per sensor, each reading the module only if it is installed. */\nfunction sensorToken<T>(pick: (expo: Sensors) => unknown, zero: T, name: string) {\n  return new InjectionToken<Sensor<T>>(`angular-native.${name}`, {\n    factory: () => {\n      const expo = expoModule('expo-sensors', () => require('expo-sensors') as Sensors);\n      return new Sensor<T>(expo ? (pick(expo) as NativeSensor<T>) : null, zero);\n    },\n  });\n}\n\n/** In g. Includes gravity, so a phone lying flat reads about 1 on z. */\nexport const Accelerometer = sensorToken<import('expo-sensors').AccelerometerMeasurement>(\n  (expo) => expo.Accelerometer,\n  STILL,\n  'accelerometer',\n);\nexport type Accelerometer = Sensor<import('expo-sensors').AccelerometerMeasurement>;\n\n/** Rotation, in radians per second. */\nexport const Gyroscope = sensorToken<import('expo-sensors').GyroscopeMeasurement>(\n  (expo) => expo.Gyroscope,\n  STILL,\n  'gyroscope',\n);\nexport type Gyroscope = Sensor<import('expo-sensors').GyroscopeMeasurement>;\n\n/** The magnetic field, in microteslas. What a compass is built on. */\nexport const Magnetometer = sensorToken<import('expo-sensors').MagnetometerMeasurement>(\n  (expo) => expo.Magnetometer,\n  STILL,\n  'magnetometer',\n);\nexport type Magnetometer = Sensor<import('expo-sensors').MagnetometerMeasurement>;\n\n/** Everything at once, plus the orientation and rotation rate derived from it. */\nexport const DeviceMotion = sensorToken<import('expo-sensors').DeviceMotionMeasurement>(\n  (expo) => expo.DeviceMotion,\n  {\n    acceleration: null,\n    accelerationIncludingGravity: STILL,\n    rotation: { alpha: 0, beta: 0, gamma: 0 },\n    rotationRate: null,\n    orientation: 0,\n    interval: 0,\n  } as import('expo-sensors').DeviceMotionMeasurement,\n  'deviceMotion',\n);\nexport type DeviceMotion = Sensor<import('expo-sensors').DeviceMotionMeasurement>;\n\n/** Air pressure, in hectopascals. Present on fewer devices than the rest; check `available`. */\nexport const Barometer = sensorToken<import('expo-sensors').BarometerMeasurement>(\n  (expo) => expo.Barometer,\n  { pressure: 0, relativeAltitude: 0 } as import('expo-sensors').BarometerMeasurement,\n  'barometer',\n);\nexport type Barometer = Sensor<import('expo-sensors').BarometerMeasurement>;\n\n/** Ambient light in lux. Android only. */\nexport const LightSensor = sensorToken<import('expo-sensors').LightSensorMeasurement>(\n  (expo) => expo.LightSensor,\n  { illuminance: 0 } as import('expo-sensors').LightSensorMeasurement,\n  'lightSensor',\n);\nexport type LightSensor = Sensor<import('expo-sensors').LightSensorMeasurement>;\n"]}

package/dist/splash-screen.d.ts

@@ -0,0 +1,73 @@
+/**
+ * `SplashScreen`, bound to `expo-splash-screen`. Held until the app has something worth showing.
+ *
+ * The whole point is the ordering, and it is easy to get subtly wrong: the native screen hides
+ * itself as soon as the first frame is drawn, so an app that loads fonts before mounting shows a
+ * blank window for as long as that takes. Preventing the auto-hide has to happen at module scope,
+ * before any of that, and hiding has to happen after the first real frame:
+ *
+ * ```ts
+ * import { splashScreen } from '@ng-native/expo/splash-screen';
+ * import { loadFonts } from '@ng-native/expo/fonts';
+ *
+ * // At module scope, before anything renders.
+ * splashScreen.hold();
+ *
+ * AppRegistry.registerRunnable('main', ({ rootTag }) => {
+ *   const fonts = loadFonts(styleSheetOf(GlobalStyles));
+ *   mount(Number(rootTag), App, getFabricUIManager(), { globalStyles: styleSheetOf(GlobalStyles) });
+ *   void splashScreen.hideWhenReady(fonts);
+ * });
+ * ```
+ *
+ * Mounting does not wait for the fonts; the splash screen does. Text laid out before they arrive
+ * is behind the splash, so nothing is ever seen in the fallback face and nothing reflows.
+ *
+ * `hideWhenReady` is that shape as one call, which is the only thing worth wrapping here: every
+ * function underneath is already a plain promise with no React in it. The class takes its
+ * platform rather than injecting it, because the first call happens before there is an injector.
+ */
+import { InjectionToken } from '@angular/core';
+/** The slice of `expo-splash-screen` this needs. */
+export interface NativeSplashScreen {
+    preventAutoHideAsync(): Promise<boolean>;
+    hideAsync(): Promise<void>;
+}
+export declare function expoSplashScreen(): NativeSplashScreen | null;
+export declare class Splash {
+    private readonly source;
+    private resolved;
+    private held;
+    /**
+     * The module, or a function that reaches it: the shared instance is created when its file is
+     * imported, and reaching the module then would fail an import rather than the first call.
+     */
+    constructor(native: NativeSplashScreen | null | (() => NativeSplashScreen | null));
+    private get native();
+    /** Whether the module is installed. Without it the screen hides itself on the first frame. */
+    get available(): boolean;
+    /**
+     * Keep the splash up. Called at module scope, before anything is mounted.
+     *
+     * Failures are swallowed: the only ones are races with the screen already having gone, and an
+     * app that cannot hold its splash should still start.
+     */
+    hold(): void;
+    /** Let it go. Safe to call whether or not it was ever held. */
+    hide(): Promise<void>;
+    /**
+     * Hide once `work` is done *and* the first frame after it has been drawn.
+     *
+     * Hiding the moment the work resolves uncovers the frame that was on screen while it ran, which
+     * is the empty one. Waiting a frame is what makes the handover invisible, and is why this is a
+     * method rather than two calls at a call site.
+     */
+    hideWhenReady(work: Promise<unknown>, nextFrame?: () => Promise<void>): Promise<void>;
+}
+/**
+ * The one instance, exported directly because it is needed before an injector exists: holding the
+ * splash is the first thing an entry file does.
+ */
+export declare const splashScreen: Splash;
+export declare const SplashScreen: InjectionToken<Splash>;
+export type SplashScreen = Splash;

package/dist/splash-screen.js

@@ -0,0 +1,115 @@
+/**
+ * `SplashScreen`, bound to `expo-splash-screen`. Held until the app has something worth showing.
+ *
+ * The whole point is the ordering, and it is easy to get subtly wrong: the native screen hides
+ * itself as soon as the first frame is drawn, so an app that loads fonts before mounting shows a
+ * blank window for as long as that takes. Preventing the auto-hide has to happen at module scope,
+ * before any of that, and hiding has to happen after the first real frame:
+ *
+ * ```ts
+ * import { splashScreen } from '@ng-native/expo/splash-screen';
+ * import { loadFonts } from '@ng-native/expo/fonts';
+ *
+ * // At module scope, before anything renders.
+ * splashScreen.hold();
+ *
+ * AppRegistry.registerRunnable('main', ({ rootTag }) => {
+ *   const fonts = loadFonts(styleSheetOf(GlobalStyles));
+ *   mount(Number(rootTag), App, getFabricUIManager(), { globalStyles: styleSheetOf(GlobalStyles) });
+ *   void splashScreen.hideWhenReady(fonts);
+ * });
+ * ```
+ *
+ * Mounting does not wait for the fonts; the splash screen does. Text laid out before they arrive
+ * is behind the splash, so nothing is ever seen in the fallback face and nothing reflows.
+ *
+ * `hideWhenReady` is that shape as one call, which is the only thing worth wrapping here: every
+ * function underneath is already a plain promise with no React in it. The class takes its
+ * platform rather than injecting it, because the first call happens before there is an injector.
+ */
+import { InjectionToken } from '@angular/core';
+import { expoModule } from "./native.js";
+export function expoSplashScreen() {
+    const expo = expoModule('expo-splash-screen', () => require('expo-splash-screen'));
+    if (!expo)
+        return null;
+    return {
+        preventAutoHideAsync: () => expo.preventAutoHideAsync(),
+        hideAsync: () => expo.hideAsync(),
+    };
+}
+export class Splash {
+    source;
+    resolved = null;
+    held = false;
+    /**
+     * The module, or a function that reaches it: the shared instance is created when its file is
+     * imported, and reaching the module then would fail an import rather than the first call.
+     */
+    constructor(native) {
+        this.source = native;
+    }
+    get native() {
+        this.resolved ??= {
+            native: typeof this.source === 'function' ? this.source() : this.source,
+        };
+        return this.resolved.native;
+    }
+    /** Whether the module is installed. Without it the screen hides itself on the first frame. */
+    get available() {
+        return this.native !== null;
+    }
+    /**
+     * Keep the splash up. Called at module scope, before anything is mounted.
+     *
+     * Failures are swallowed: the only ones are races with the screen already having gone, and an
+     * app that cannot hold its splash should still start.
+     */
+    hold() {
+        if (!this.native || this.held)
+            return;
+        this.held = true;
+        void this.native.preventAutoHideAsync().catch(() => { });
+    }
+    /** Let it go. Safe to call whether or not it was ever held. */
+    async hide() {
+        if (!this.native)
+            return;
+        this.held = false;
+        await this.native.hideAsync().catch(() => { });
+    }
+    /**
+     * Hide once `work` is done *and* the first frame after it has been drawn.
+     *
+     * Hiding the moment the work resolves uncovers the frame that was on screen while it ran, which
+     * is the empty one. Waiting a frame is what makes the handover invisible, and is why this is a
+     * method rather than two calls at a call site.
+     */
+    async hideWhenReady(work, nextFrame = defaultFrame) {
+        try {
+            await work;
+        }
+        finally {
+            await nextFrame();
+            await this.hide();
+        }
+    }
+}
+/** One turn of the frame loop, or the macrotask queue where there is no loop to wait on. */
+const defaultFrame = () => new Promise((resolve) => {
+    const raf = globalThis
+        .requestAnimationFrame;
+    if (raf)
+        raf(() => resolve());
+    else
+        setTimeout(resolve, 0);
+});
+/**
+ * The one instance, exported directly because it is needed before an injector exists: holding the
+ * splash is the first thing an entry file does.
+ */
+export const splashScreen = new Splash(expoSplashScreen);
+export const SplashScreen = new InjectionToken('angular-native.splashScreen', {
+    factory: () => splashScreen,
+});
+//# sourceMappingURL=splash-screen.js.map

package/dist/splash-screen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splash-screen.js","sourceRoot":"","sources":["../src/splash-screen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAQzC,MAAM,UAAU,gBAAgB;IAC9B,MAAM,IAAI,GAAG,UAAU,CACrB,oBAAoB,EACpB,GAAG,EAAE,CAAC,OAAO,CAAC,oBAAoB,CAAwC,CAC3E,CAAC;IACF,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACvB,OAAO;QACL,oBAAoB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE;QACvD,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE;KAClC,CAAC;AACJ,CAAC;AAED,MAAM,OAAO,MAAM;IACA,MAAM,CAAgE;IAC/E,QAAQ,GAA0D,IAAI,CAAC;IACvE,IAAI,GAAG,KAAK,CAAC;IAErB;;;OAGG;IACH,YAAY,MAAqE;QAC/E,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,IAAY,MAAM;QAChB,IAAI,CAAC,QAAQ,KAAK;YAChB,MAAM,EAAE,OAAO,IAAI,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM;SACxE,CAAC;QACF,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;IAC9B,CAAC;IAED,8FAA8F;IAC9F,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACH,IAAI;QACF,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI;YAAE,OAAO;QACtC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,KAAK,IAAI,CAAC,MAAM,CAAC,oBAAoB,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IAC1D,CAAC;IAED,+DAA+D;IAC/D,KAAK,CAAC,IAAI;QACR,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO;QACzB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,aAAa,CAAC,IAAsB,EAAE,SAAS,GAAG,YAAY;QAClE,IAAI,CAAC;YACH,MAAM,IAAI,CAAC;QACb,CAAC;gBAAS,CAAC;YACT,MAAM,SAAS,EAAE,CAAC;YAClB,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QACpB,CAAC;IACH,CAAC;CACF;AAED,4FAA4F;AAC5F,MAAM,YAAY,GAAG,GAAkB,EAAE,CACvC,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;IACtB,MAAM,GAAG,GAAI,UAAmE;SAC7E,qBAAqB,CAAC;IACzB,IAAI,GAAG;QAAE,GAAG,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;;QACzB,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;AAC9B,CAAC,CAAC,CAAC;AAEL;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAEzD,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,cAAc,CAAS,6BAA6B,EAAE;IACpF,OAAO,EAAE,GAAG,EAAE,CAAC,YAAY;CAC5B,CAAC,CAAC","sourcesContent":["/**\n * `SplashScreen`, bound to `expo-splash-screen`. Held until the app has something worth showing.\n *\n * The whole point is the ordering, and it is easy to get subtly wrong: the native screen hides\n * itself as soon as the first frame is drawn, so an app that loads fonts before mounting shows a\n * blank window for as long as that takes. Preventing the auto-hide has to happen at module scope,\n * before any of that, and hiding has to happen after the first real frame:\n *\n * ```ts\n * import { splashScreen } from '@ng-native/expo/splash-screen';\n * import { loadFonts } from '@ng-native/expo/fonts';\n *\n * // At module scope, before anything renders.\n * splashScreen.hold();\n *\n * AppRegistry.registerRunnable('main', ({ rootTag }) => {\n *   const fonts = loadFonts(styleSheetOf(GlobalStyles));\n *   mount(Number(rootTag), App, getFabricUIManager(), { globalStyles: styleSheetOf(GlobalStyles) });\n *   void splashScreen.hideWhenReady(fonts);\n * });\n * ```\n *\n * Mounting does not wait for the fonts; the splash screen does. Text laid out before they arrive\n * is behind the splash, so nothing is ever seen in the fallback face and nothing reflows.\n *\n * `hideWhenReady` is that shape as one call, which is the only thing worth wrapping here: every\n * function underneath is already a plain promise with no React in it. The class takes its\n * platform rather than injecting it, because the first call happens before there is an injector.\n */\nimport { InjectionToken } from '@angular/core';\nimport { expoModule } from './native.ts';\n\n/** The slice of `expo-splash-screen` this needs. */\nexport interface NativeSplashScreen {\n  preventAutoHideAsync(): Promise<boolean>;\n  hideAsync(): Promise<void>;\n}\n\nexport function expoSplashScreen(): NativeSplashScreen | null {\n  const expo = expoModule(\n    'expo-splash-screen',\n    () => require('expo-splash-screen') as typeof import('expo-splash-screen'),\n  );\n  if (!expo) return null;\n  return {\n    preventAutoHideAsync: () => expo.preventAutoHideAsync(),\n    hideAsync: () => expo.hideAsync(),\n  };\n}\n\nexport class Splash {\n  private readonly source: NativeSplashScreen | null | (() => NativeSplashScreen | null);\n  private resolved: { readonly native: NativeSplashScreen | null } | null = null;\n  private held = false;\n\n  /**\n   * The module, or a function that reaches it: the shared instance is created when its file is\n   * imported, and reaching the module then would fail an import rather than the first call.\n   */\n  constructor(native: NativeSplashScreen | null | (() => NativeSplashScreen | null)) {\n    this.source = native;\n  }\n\n  private get native(): NativeSplashScreen | null {\n    this.resolved ??= {\n      native: typeof this.source === 'function' ? this.source() : this.source,\n    };\n    return this.resolved.native;\n  }\n\n  /** Whether the module is installed. Without it the screen hides itself on the first frame. */\n  get available(): boolean {\n    return this.native !== null;\n  }\n\n  /**\n   * Keep the splash up. Called at module scope, before anything is mounted.\n   *\n   * Failures are swallowed: the only ones are races with the screen already having gone, and an\n   * app that cannot hold its splash should still start.\n   */\n  hold(): void {\n    if (!this.native || this.held) return;\n    this.held = true;\n    void this.native.preventAutoHideAsync().catch(() => {});\n  }\n\n  /** Let it go. Safe to call whether or not it was ever held. */\n  async hide(): Promise<void> {\n    if (!this.native) return;\n    this.held = false;\n    await this.native.hideAsync().catch(() => {});\n  }\n\n  /**\n   * Hide once `work` is done *and* the first frame after it has been drawn.\n   *\n   * Hiding the moment the work resolves uncovers the frame that was on screen while it ran, which\n   * is the empty one. Waiting a frame is what makes the handover invisible, and is why this is a\n   * method rather than two calls at a call site.\n   */\n  async hideWhenReady(work: Promise<unknown>, nextFrame = defaultFrame): Promise<void> {\n    try {\n      await work;\n    } finally {\n      await nextFrame();\n      await this.hide();\n    }\n  }\n}\n\n/** One turn of the frame loop, or the macrotask queue where there is no loop to wait on. */\nconst defaultFrame = (): Promise<void> =>\n  new Promise((resolve) => {\n    const raf = (globalThis as { requestAnimationFrame?: (cb: () => void) => void })\n      .requestAnimationFrame;\n    if (raf) raf(() => resolve());\n    else setTimeout(resolve, 0);\n  });\n\n/**\n * The one instance, exported directly because it is needed before an injector exists: holding the\n * splash is the first thing an entry file does.\n */\nexport const splashScreen = new Splash(expoSplashScreen);\n\nexport const SplashScreen = new InjectionToken<Splash>('angular-native.splashScreen', {\n  factory: () => splashScreen,\n});\nexport type SplashScreen = Splash;\n"]}