@ng-native/expo 0.0.1 → 0.1.0

package/dist/biometrics.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `Biometrics`, bound to `expo-local-authentication`.
+ *
+ * ```ts
+ * private readonly biometrics = inject(Biometrics);
+ * const { success } = await this.biometrics.authenticate('Unlock your wallet');
+ * ```
+ *
+ * Face ID needs `NSFaceIDUsageDescription` in the app config, or iOS ends the app the first time
+ * it is asked for; `expo-local-authentication`'s config plugin writes it.
+ */
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export type BiometricKind = 'fingerprint' | 'face' | 'iris';
+/** Passed, or the platform's reason it did not: `user_cancel`, `lockout`, `not_enrolled`... */
+export type AuthenticationResult = {
+    success: true;
+} | {
+    success: false;
+    error: string;
+};
+export type AuthenticateOptions = Omit<import('expo-local-authentication').LocalAuthenticationOptions, 'promptMessage'>;
+/** The slice of `expo-local-authentication` this needs. */
+export interface NativeBiometrics {
+    hasHardwareAsync(): Promise<boolean>;
+    isEnrolledAsync(): Promise<boolean>;
+    supportedAuthenticationTypesAsync(): Promise<number[]>;
+    authenticateAsync(options?: import('expo-local-authentication').LocalAuthenticationOptions): Promise<AuthenticationResult>;
+}
+export declare class Biometrics {
+    /** Overridden in a test to pass or fail without a face. */
+    static readonly SOURCE: InjectionToken<NativeBiometrics | null>;
+    private readonly native;
+    /** Whether there is a sensor and something enrolled on it: whether asking can succeed. */
+    available(): Promise<boolean>;
+    /** The kinds the device has, for a button that says "Use Face ID" rather than "Use biometrics". */
+    kinds(): Promise<BiometricKind[]>;
+    /**
+     * Show the system prompt. Without the module this fails rather than passes: a lock that opens
+     * when its sensor is missing is not a lock.
+     */
+    authenticate(message: string, options?: AuthenticateOptions): Promise<AuthenticationResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Biometrics, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/dist/biometrics.js

@@ -0,0 +1,53 @@
+/**
+ * `Biometrics`, bound to `expo-local-authentication`.
+ *
+ * ```ts
+ * private readonly biometrics = inject(Biometrics);
+ * const { success } = await this.biometrics.authenticate('Unlock your wallet');
+ * ```
+ *
+ * Face ID needs `NSFaceIDUsageDescription` in the app config, or iOS ends the app the first time
+ * it is asked for; `expo-local-authentication`'s config plugin writes it.
+ */
+import { InjectionToken, Service, inject } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+/** Expo's `AuthenticationType` enum, whose values are these numbers. */
+const KINDS = { 1: 'fingerprint', 2: 'face', 3: 'iris' };
+export class Biometrics {
+    /** Overridden in a test to pass or fail without a face. */
+    static SOURCE = new InjectionToken('angular-native.biometricsSource', {
+        factory: () => expoModule('expo-local-authentication', () => require('expo-local-authentication')) ?? null,
+    });
+    native = inject(Biometrics.SOURCE);
+    /** Whether there is a sensor and something enrolled on it: whether asking can succeed. */
+    async available() {
+        if (!this.native)
+            return false;
+        const [hardware, enrolled] = await Promise.all([
+            this.native.hasHardwareAsync(),
+            this.native.isEnrolledAsync(),
+        ]);
+        return hardware && enrolled;
+    }
+    /** The kinds the device has, for a button that says "Use Face ID" rather than "Use biometrics". */
+    async kinds() {
+        const types = (await this.native?.supportedAuthenticationTypesAsync()) ?? [];
+        return types.flatMap((type) => KINDS[type] ?? []);
+    }
+    /**
+     * Show the system prompt. Without the module this fails rather than passes: a lock that opens
+     * when its sensor is missing is not a lock.
+     */
+    async authenticate(message, options = {}) {
+        if (!this.native)
+            return { success: false, error: 'not_available' };
+        return this.native.authenticateAsync({ promptMessage: message, ...options });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Biometrics, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: Biometrics });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Biometrics, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=biometrics.js.map

package/dist/biometrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"biometrics.js","sourceRoot":"","sources":["../src/biometrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;;AAIzC,wEAAwE;AACxE,MAAM,KAAK,GAAkC,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC;AAqBxF,MAAM,OAAO,UAAU;IACrB,2DAA2D;IAC3D,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,iCAAiC,EACjC;QACE,OAAO,EAAE,GAAG,EAAE,CACZ,UAAU,CACR,2BAA2B,EAC3B,GAAG,EAAE,CAAC,OAAO,CAAC,2BAA2B,CAAqB,CAC/D,IAAI,IAAI;KACZ,CACF,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAEpD,0FAA0F;IAC1F,KAAK,CAAC,SAAS;QACb,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QAC/B,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAC7C,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE;YAC9B,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE;SAC9B,CAAC,CAAC;QACH,OAAO,QAAQ,IAAI,QAAQ,CAAC;IAC9B,CAAC;IAED,mGAAmG;IACnG,KAAK,CAAC,KAAK;QACT,MAAM,KAAK,GAAG,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,iCAAiC,EAAE,CAAC,IAAI,EAAE,CAAC;QAC7E,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,YAAY,CAChB,OAAe,EACf,UAA+B,EAAE;QAEjC,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,CAAC;QACpE,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,EAAE,aAAa,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC/E,CAAC;uGAzCU,UAAU;wGAAV,UAAU;;2FAAV,UAAU;kBADtB,OAAO","sourcesContent":["/**\n * `Biometrics`, bound to `expo-local-authentication`.\n *\n * ```ts\n * private readonly biometrics = inject(Biometrics);\n * const { success } = await this.biometrics.authenticate('Unlock your wallet');\n * ```\n *\n * Face ID needs `NSFaceIDUsageDescription` in the app config, or iOS ends the app the first time\n * it is asked for; `expo-local-authentication`'s config plugin writes it.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport { expoModule } from './native.ts';\n\nexport type BiometricKind = 'fingerprint' | 'face' | 'iris';\n\n/** Expo's `AuthenticationType` enum, whose values are these numbers. */\nconst KINDS: Record<number, BiometricKind> = { 1: 'fingerprint', 2: 'face', 3: 'iris' };\n\n/** Passed, or the platform's reason it did not: `user_cancel`, `lockout`, `not_enrolled`... */\nexport type AuthenticationResult = { success: true } | { success: false; error: string };\n\nexport type AuthenticateOptions = Omit<\n  import('expo-local-authentication').LocalAuthenticationOptions,\n  'promptMessage'\n>;\n\n/** The slice of `expo-local-authentication` this needs. */\nexport interface NativeBiometrics {\n  hasHardwareAsync(): Promise<boolean>;\n  isEnrolledAsync(): Promise<boolean>;\n  supportedAuthenticationTypesAsync(): Promise<number[]>;\n  authenticateAsync(\n    options?: import('expo-local-authentication').LocalAuthenticationOptions,\n  ): Promise<AuthenticationResult>;\n}\n\n@Service()\nexport class Biometrics {\n  /** Overridden in a test to pass or fail without a face. */\n  static readonly SOURCE = new InjectionToken<NativeBiometrics | null>(\n    'angular-native.biometricsSource',\n    {\n      factory: () =>\n        expoModule(\n          'expo-local-authentication',\n          () => require('expo-local-authentication') as NativeBiometrics,\n        ) ?? null,\n    },\n  );\n\n  private readonly native = inject(Biometrics.SOURCE);\n\n  /** Whether there is a sensor and something enrolled on it: whether asking can succeed. */\n  async available(): Promise<boolean> {\n    if (!this.native) return false;\n    const [hardware, enrolled] = await Promise.all([\n      this.native.hasHardwareAsync(),\n      this.native.isEnrolledAsync(),\n    ]);\n    return hardware && enrolled;\n  }\n\n  /** The kinds the device has, for a button that says \"Use Face ID\" rather than \"Use biometrics\". */\n  async kinds(): Promise<BiometricKind[]> {\n    const types = (await this.native?.supportedAuthenticationTypesAsync()) ?? [];\n    return types.flatMap((type) => KINDS[type] ?? []);\n  }\n\n  /**\n   * Show the system prompt. Without the module this fails rather than passes: a lock that opens\n   * when its sensor is missing is not a lock.\n   */\n  async authenticate(\n    message: string,\n    options: AuthenticateOptions = {},\n  ): Promise<AuthenticationResult> {\n    if (!this.native) return { success: false, error: 'not_available' };\n    return this.native.authenticateAsync({ promptMessage: message, ...options });\n  }\n}\n"]}

package/dist/brightness.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `Brightness`, bound to `expo-brightness`.
+ *
+ * For the screens that have a reason to change it: a boarding pass, a QR code.
+ *
+ * The app's own brightness only. The system one is a global setting an app can leave changed
+ * after it is gone, and needs a permission on Android - a decision to make deliberately against
+ * Expo's own API rather than to reach through a convenience here.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface NativeBrightness {
+    get(): Promise<number>;
+    set(level: number): Promise<void>;
+    restore(): Promise<void>;
+}
+export declare class Brightness {
+    /** Overridden in a test to watch the level without changing a screen. */
+    static readonly SOURCE: InjectionToken<NativeBrightness | null>;
+    private readonly native;
+    private readonly current;
+    /** Nought to one. One until the platform answers, since that is what a screen already shows. */
+    readonly level: Signal<number>;
+    constructor();
+    /**
+     * Set it, and return the function that puts it back.
+     *
+     * Always paired, because the alternative is an app that leaves the screen at full brightness
+     * after the boarding pass has been shown - which the user experiences as a battery fault.
+     */
+    set(level: number): () => void;
+    /** Every level set and not yet put back, the one in force last. */
+    private readonly levels;
+    private apply;
+    restore(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Brightness, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/dist/brightness.js

@@ -0,0 +1,81 @@
+/**
+ * `Brightness`, bound to `expo-brightness`.
+ *
+ * For the screens that have a reason to change it: a boarding pass, a QR code.
+ *
+ * The app's own brightness only. The system one is a global setting an app can leave changed
+ * after it is gone, and needs a permission on Android - a decision to make deliberately against
+ * Expo's own API rather than to reach through a convenience here.
+ */
+import { InjectionToken, Service, inject, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+export class Brightness {
+    /** Overridden in a test to watch the level without changing a screen. */
+    static SOURCE = new InjectionToken('angular-native.brightnessSource', {
+        factory: () => {
+            const expo = expoModule('expo-brightness', () => require('expo-brightness'));
+            if (!expo)
+                return null;
+            return {
+                get: () => expo.getBrightnessAsync(),
+                set: (level) => expo.setBrightnessAsync(level),
+                restore: () => expo.restoreSystemBrightnessAsync(),
+            };
+        },
+    });
+    native = inject(Brightness.SOURCE);
+    current = signal(1, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "current" }] : /* istanbul ignore next */ []));
+    /** Nought to one. One until the platform answers, since that is what a screen already shows. */
+    level = this.current.asReadonly();
+    constructor() {
+        void this.native?.get().then((level) => this.current.set(level), () => { });
+    }
+    /**
+     * Set it, and return the function that puts it back.
+     *
+     * Always paired, because the alternative is an app that leaves the screen at full brightness
+     * after the boarding pass has been shown - which the user experiences as a battery fault.
+     */
+    set(level) {
+        const clamped = Math.min(1, Math.max(0, level));
+        // A stack, as the status bar's is: a screen pushed over one that set a level of its own puts
+        // back the level beneath it, not the system's, when it goes.
+        const entry = { level: clamped };
+        this.levels.push(entry);
+        this.apply(clamped);
+        return () => {
+            const at = this.levels.indexOf(entry);
+            if (at === -1)
+                return;
+            this.levels.splice(at, 1);
+            if (at < this.levels.length)
+                return;
+            const below = this.levels.at(-1);
+            if (below)
+                this.apply(below.level);
+            else
+                this.restore();
+        };
+    }
+    /** Every level set and not yet put back, the one in force last. */
+    levels = [];
+    apply(level) {
+        this.current.set(level);
+        void this.native?.set(level);
+    }
+    restore() {
+        // Everything set so far is put back, so a release still to come has nothing left to undo.
+        this.levels.length = 0;
+        void this.native
+            ?.restore()
+            .then(() => this.native?.get().then((level) => this.current.set(level)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Brightness, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: Brightness });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Brightness, decorators: [{
+            type: Service
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=brightness.js.map

package/dist/brightness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brightness.js","sourceRoot":"","sources":["../src/brightness.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `Brightness`, bound to `expo-brightness`.\n *\n * For the screens that have a reason to change it: a boarding pass, a QR code.\n *\n * The app's own brightness only. The system one is a global setting an app can leave changed\n * after it is gone, and needs a permission on Android - a decision to make deliberately against\n * Expo's own API rather than to reach through a convenience here.\n */\nimport { InjectionToken, Service, inject, signal, type Signal } from '@angular/core';\nimport { expoModule } from './native.ts';\n\nexport interface NativeBrightness {\n  get(): Promise<number>;\n  set(level: number): Promise<void>;\n  restore(): Promise<void>;\n}\n\n@Service()\nexport class Brightness {\n  /** Overridden in a test to watch the level without changing a screen. */\n  static readonly SOURCE = new InjectionToken<NativeBrightness | null>(\n    'angular-native.brightnessSource',\n    {\n      factory: () => {\n        const expo = expoModule(\n          'expo-brightness',\n          () => require('expo-brightness') as typeof import('expo-brightness'),\n        );\n        if (!expo) return null;\n        return {\n          get: () => expo.getBrightnessAsync(),\n          set: (level) => expo.setBrightnessAsync(level),\n          restore: () => expo.restoreSystemBrightnessAsync(),\n        };\n      },\n    },\n  );\n\n  private readonly native = inject(Brightness.SOURCE);\n  private readonly current = signal(1);\n\n  /** Nought to one. One until the platform answers, since that is what a screen already shows. */\n  readonly level: Signal<number> = this.current.asReadonly();\n\n  constructor() {\n    void this.native?.get().then(\n      (level) => this.current.set(level),\n      () => {},\n    );\n  }\n\n  /**\n   * Set it, and return the function that puts it back.\n   *\n   * Always paired, because the alternative is an app that leaves the screen at full brightness\n   * after the boarding pass has been shown - which the user experiences as a battery fault.\n   */\n  set(level: number): () => void {\n    const clamped = Math.min(1, Math.max(0, level));\n    // A stack, as the status bar's is: a screen pushed over one that set a level of its own puts\n    // back the level beneath it, not the system's, when it goes.\n    const entry = { level: clamped };\n    this.levels.push(entry);\n    this.apply(clamped);\n    return () => {\n      const at = this.levels.indexOf(entry);\n      if (at === -1) return;\n      this.levels.splice(at, 1);\n      if (at < this.levels.length) return;\n      const below = this.levels.at(-1);\n      if (below) this.apply(below.level);\n      else this.restore();\n    };\n  }\n\n  /** Every level set and not yet put back, the one in force last. */\n  private readonly levels: { readonly level: number }[] = [];\n\n  private apply(level: number): void {\n    this.current.set(level);\n    void this.native?.set(level);\n  }\n\n  restore(): void {\n    // Everything set so far is put back, so a release still to come has nothing left to undo.\n    this.levels.length = 0;\n    void this.native\n      ?.restore()\n      .then(() => this.native?.get().then((level) => this.current.set(level)));\n  }\n}\n"]}

package/dist/browser.d.ts

@@ -0,0 +1,42 @@
+/**
+ * `Browser`, bound to `expo-web-browser`: a page in an in-app browser, and a sign-in through one.
+ *
+ * ```ts
+ * private readonly browser = inject(Browser);
+ * const returned = await this.browser.signIn(authorizeUrl, 'myapp://signed-in');
+ * ```
+ *
+ * `signIn` opens the system's authentication session (`ASWebAuthenticationSession` on iOS, a
+ * Custom Tab on Android), which shares the browser's cookies and closes itself when the page
+ * redirects to the app's URL. What comes back is that URL, with its `code` or `token`, for the app
+ * to exchange. For the full OAuth flow with PKCE, `expo-auth-session`'s `AuthRequest` is a plain
+ * class that needs no React; its `promptAsync` opens this same session.
+ */
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/** The slice of `expo-web-browser` this needs. */
+export interface NativeBrowser {
+    openBrowserAsync(url: string): Promise<{
+        type: string;
+    }>;
+    openAuthSessionAsync(url: string, redirectUrl?: string | null): Promise<{
+        type: 'success';
+        url: string;
+    } | {
+        type: string;
+    }>;
+}
+export declare class Browser {
+    /** Overridden in a test to sign in without a browser. */
+    static readonly SOURCE: InjectionToken<NativeBrowser | null>;
+    private readonly native;
+    /** Open a page in the in-app browser. Resolves when it is closed. */
+    open(url: string): Promise<void>;
+    /**
+     * Open a sign-in page, and resolve to the URL it redirected back to - or null if they closed it
+     * first.
+     */
+    signIn(url: string, redirectUrl: string): Promise<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Browser, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/dist/browser.js

@@ -0,0 +1,42 @@
+/**
+ * `Browser`, bound to `expo-web-browser`: a page in an in-app browser, and a sign-in through one.
+ *
+ * ```ts
+ * private readonly browser = inject(Browser);
+ * const returned = await this.browser.signIn(authorizeUrl, 'myapp://signed-in');
+ * ```
+ *
+ * `signIn` opens the system's authentication session (`ASWebAuthenticationSession` on iOS, a
+ * Custom Tab on Android), which shares the browser's cookies and closes itself when the page
+ * redirects to the app's URL. What comes back is that URL, with its `code` or `token`, for the app
+ * to exchange. For the full OAuth flow with PKCE, `expo-auth-session`'s `AuthRequest` is a plain
+ * class that needs no React; its `promptAsync` opens this same session.
+ */
+import { InjectionToken, Service, inject } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+export class Browser {
+    /** Overridden in a test to sign in without a browser. */
+    static SOURCE = new InjectionToken('angular-native.browserSource', {
+        factory: () => expoModule('expo-web-browser', () => require('expo-web-browser')) ?? null,
+    });
+    native = inject(Browser.SOURCE);
+    /** Open a page in the in-app browser. Resolves when it is closed. */
+    async open(url) {
+        await this.native?.openBrowserAsync(url);
+    }
+    /**
+     * Open a sign-in page, and resolve to the URL it redirected back to - or null if they closed it
+     * first.
+     */
+    async signIn(url, redirectUrl) {
+        const result = await this.native?.openAuthSessionAsync(url, redirectUrl);
+        return result?.type === 'success' && 'url' in result ? result.url : null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Browser, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: Browser });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Browser, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;;AAczC,MAAM,OAAO,OAAO;IAClB,yDAAyD;IACzD,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,8BAA8B,EAC9B;QACE,OAAO,EAAE,GAAG,EAAE,CACZ,UAAU,CAAC,kBAAkB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,kBAAkB,CAAS,CAAC,IAAI,IAAI;KACpF,CACF,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAEjD,qEAAqE;IACrE,KAAK,CAAC,IAAI,CAAC,GAAW;QACpB,MAAM,IAAI,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,MAAM,CAAC,GAAW,EAAE,WAAmB;QAC3C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;QACzE,OAAO,MAAM,EAAE,IAAI,KAAK,SAAS,IAAI,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3E,CAAC;uGAxBU,OAAO;wGAAP,OAAO;;2FAAP,OAAO;kBADnB,OAAO","sourcesContent":["/**\n * `Browser`, bound to `expo-web-browser`: a page in an in-app browser, and a sign-in through one.\n *\n * ```ts\n * private readonly browser = inject(Browser);\n * const returned = await this.browser.signIn(authorizeUrl, 'myapp://signed-in');\n * ```\n *\n * `signIn` opens the system's authentication session (`ASWebAuthenticationSession` on iOS, a\n * Custom Tab on Android), which shares the browser's cookies and closes itself when the page\n * redirects to the app's URL. What comes back is that URL, with its `code` or `token`, for the app\n * to exchange. For the full OAuth flow with PKCE, `expo-auth-session`'s `AuthRequest` is a plain\n * class that needs no React; its `promptAsync` opens this same session.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport { expoModule } from './native.ts';\n\ntype Expo = typeof import('expo-web-browser');\n\n/** The slice of `expo-web-browser` this needs. */\nexport interface NativeBrowser {\n  openBrowserAsync(url: string): Promise<{ type: string }>;\n  openAuthSessionAsync(\n    url: string,\n    redirectUrl?: string | null,\n  ): Promise<{ type: 'success'; url: string } | { type: string }>;\n}\n\n@Service()\nexport class Browser {\n  /** Overridden in a test to sign in without a browser. */\n  static readonly SOURCE = new InjectionToken<NativeBrowser | null>(\n    'angular-native.browserSource',\n    {\n      factory: () =>\n        expoModule('expo-web-browser', () => require('expo-web-browser') as Expo) ?? null,\n    },\n  );\n\n  private readonly native = inject(Browser.SOURCE);\n\n  /** Open a page in the in-app browser. Resolves when it is closed. */\n  async open(url: string): Promise<void> {\n    await this.native?.openBrowserAsync(url);\n  }\n\n  /**\n   * Open a sign-in page, and resolve to the URL it redirected back to - or null if they closed it\n   * first.\n   */\n  async signIn(url: string, redirectUrl: string): Promise<string | null> {\n    const result = await this.native?.openAuthSessionAsync(url, redirectUrl);\n    return result?.type === 'success' && 'url' in result ? result.url : null;\n  }\n}\n"]}

package/dist/camera.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `Camera`: a picture taken from the `<expo-camera>` view on screen.
+ *
+ * ```ts
+ * registerExpoViews('expo-camera'); // once, at startup
+ *
+ * @Component({
+ *   imports: [Camera],
+ *   template: `<expo-camera facing="back" class="flex-1" />`,
+ * })
+ * export class Scanner {
+ *   private readonly camera = viewChild.required(Camera);
+ *   async shoot() { const picture = await this.camera().takePicture({ quality: 0.8 }); }
+ * }
+ * ```
+ *
+ * Importing it is all it takes: it applies to every `<expo-camera>` in the template. The view is
+ * what takes the picture, so this is a directive on the view rather than a service.
+ *
+ * In React, `takePictureAsync` is a method on the component's ref. Underneath, it is one of the
+ * functions Expo defines on the view (`AsyncFunction("takePicture")` in the module), which native
+ * finds by reading `nativeTag` off whatever it is called on. So this calls the same function with
+ * the tag the engine committed the view under, and no ref is needed.
+ */
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export type PictureOptions = Omit<import('expo-camera').CameraPictureOptions, 'onPictureSaved' | 'pictureRef'>;
+export type CameraPicture = import('expo-camera').CameraCapturedPicture;
+/** The functions `expo-camera` defines on its view, called with the view's tag as `this`. */
+export interface CameraViewFunctions {
+    takePicture(this: {
+        nativeTag: number;
+    }, options: PictureOptions): Promise<CameraPicture>;
+}
+export declare class Camera {
+    /** Overridden in a test to take pictures without a camera. */
+    static readonly SOURCE: InjectionToken<CameraViewFunctions | null>;
+    private readonly functions;
+    private readonly engine;
+    private readonly node;
+    /**
+     * Take a picture. Null without the module, or before the view has reached the screen - there is
+     * no camera to take it with yet.
+     */
+    takePicture(options?: PictureOptions): Promise<CameraPicture | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Camera, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Camera, "expo-camera", ["camera"], {}, {}, never, never, true, never>;
+}

package/dist/camera.js

@@ -0,0 +1,59 @@
+/**
+ * `Camera`: a picture taken from the `<expo-camera>` view on screen.
+ *
+ * ```ts
+ * registerExpoViews('expo-camera'); // once, at startup
+ *
+ * @Component({
+ *   imports: [Camera],
+ *   template: `<expo-camera facing="back" class="flex-1" />`,
+ * })
+ * export class Scanner {
+ *   private readonly camera = viewChild.required(Camera);
+ *   async shoot() { const picture = await this.camera().takePicture({ quality: 0.8 }); }
+ * }
+ * ```
+ *
+ * Importing it is all it takes: it applies to every `<expo-camera>` in the template. The view is
+ * what takes the picture, so this is a directive on the view rather than a service.
+ *
+ * In React, `takePictureAsync` is a method on the component's ref. Underneath, it is one of the
+ * functions Expo defines on the view (`AsyncFunction("takePicture")` in the module), which native
+ * finds by reading `nativeTag` off whatever it is called on. So this calls the same function with
+ * the tag the engine committed the view under, and no ref is needed.
+ */
+import { Directive, ElementRef, InjectionToken, inject } from '@angular/core';
+import { Engine } from '@ng-native/fabric';
+import { expoModule, optional } from "./native.js";
+import * as i0 from "@angular/core";
+export class Camera {
+    /** Overridden in a test to take pictures without a camera. */
+    static SOURCE = new InjectionToken('angular-native.cameraSource', {
+        factory: () => {
+            const core = optional(() => require('expo-modules-core'));
+            const module = expoModule('expo-camera', () => core?.requireOptionalNativeModule('ExpoCamera'));
+            // The camera is the module's first view, so its functions are under the module's name.
+            return module?.ViewPrototypes?.['ExpoCamera'] ?? null;
+        },
+    });
+    functions = inject(Camera.SOURCE);
+    engine = inject(Engine);
+    node = inject(ElementRef).nativeElement;
+    /**
+     * Take a picture. Null without the module, or before the view has reached the screen - there is
+     * no camera to take it with yet.
+     */
+    async takePicture(options = {}) {
+        const nativeTag = this.engine.tagOf(this.node);
+        if (!this.functions || nativeTag === null)
+            return null;
+        return this.functions.takePicture.call({ nativeTag }, options);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Camera, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.0", type: Camera, isStandalone: true, selector: "expo-camera", exportAs: ["camera"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Camera, decorators: [{
+            type: Directive,
+            args: [{ selector: 'expo-camera', exportAs: 'camera' }]
+        }] });
+//# sourceMappingURL=camera.js.map

package/dist/camera.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.js","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,MAAM,EAAmB,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;;AAcnD,MAAM,OAAO,MAAM;IACjB,8DAA8D;IAC9D,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,6BAA6B,EAC7B;QACE,OAAO,EAAE,GAAG,EAAE;YACZ,MAAM,IAAI,GAAG,QAAQ,CACnB,GAAG,EAAE,CAAC,OAAO,CAAC,mBAAmB,CAAuC,CACzE,CAAC;YACF,MAAM,MAAM,GAAG,UAAU,CAAC,aAAa,EAAE,GAAG,EAAE,CAC5C,IAAI,EAAE,2BAA2B,CAE9B,YAAY,CAAC,CACjB,CAAC;YACF,uFAAuF;YACvF,OAAO,MAAM,EAAE,cAAc,EAAE,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC;QACxD,CAAC;KACF,CACF,CAAC;IAEe,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IACxB,IAAI,GAAG,MAAM,CAAyB,UAAU,CAAC,CAAC,aAAa,CAAC;IAEjF;;;OAGG;IACH,KAAK,CAAC,WAAW,CAAC,UAA0B,EAAE;QAC5C,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/C,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;QACvD,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC;uGAhCU,MAAM;2FAAN,MAAM;;2FAAN,MAAM;kBADlB,SAAS;mBAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE","sourcesContent":["/**\n * `Camera`: a picture taken from the `<expo-camera>` view on screen.\n *\n * ```ts\n * registerExpoViews('expo-camera'); // once, at startup\n *\n * @Component({\n *   imports: [Camera],\n *   template: `<expo-camera facing=\"back\" class=\"flex-1\" />`,\n * })\n * export class Scanner {\n *   private readonly camera = viewChild.required(Camera);\n *   async shoot() { const picture = await this.camera().takePicture({ quality: 0.8 }); }\n * }\n * ```\n *\n * Importing it is all it takes: it applies to every `<expo-camera>` in the template. The view is\n * what takes the picture, so this is a directive on the view rather than a service.\n *\n * In React, `takePictureAsync` is a method on the component's ref. Underneath, it is one of the\n * functions Expo defines on the view (`AsyncFunction(\"takePicture\")` in the module), which native\n * finds by reading `nativeTag` off whatever it is called on. So this calls the same function with\n * the tag the engine committed the view under, and no ref is needed.\n */\nimport { Directive, ElementRef, InjectionToken, inject } from '@angular/core';\nimport { Engine, type EngineNode } from '@ng-native/fabric';\nimport { expoModule, optional } from './native.ts';\n\nexport type PictureOptions = Omit<\n  import('expo-camera').CameraPictureOptions,\n  'onPictureSaved' | 'pictureRef'\n>;\nexport type CameraPicture = import('expo-camera').CameraCapturedPicture;\n\n/** The functions `expo-camera` defines on its view, called with the view's tag as `this`. */\nexport interface CameraViewFunctions {\n  takePicture(this: { nativeTag: number }, options: PictureOptions): Promise<CameraPicture>;\n}\n\n@Directive({ selector: 'expo-camera', exportAs: 'camera' })\nexport class Camera {\n  /** Overridden in a test to take pictures without a camera. */\n  static readonly SOURCE = new InjectionToken<CameraViewFunctions | null>(\n    'angular-native.cameraSource',\n    {\n      factory: () => {\n        const core = optional(\n          () => require('expo-modules-core') as typeof import('expo-modules-core'),\n        );\n        const module = expoModule('expo-camera', () =>\n          core?.requireOptionalNativeModule<{\n            ViewPrototypes?: Record<string, CameraViewFunctions>;\n          }>('ExpoCamera'),\n        );\n        // The camera is the module's first view, so its functions are under the module's name.\n        return module?.ViewPrototypes?.['ExpoCamera'] ?? null;\n      },\n    },\n  );\n\n  private readonly functions = inject(Camera.SOURCE);\n  private readonly engine = inject(Engine);\n  private readonly node = inject<ElementRef<EngineNode>>(ElementRef).nativeElement;\n\n  /**\n   * Take a picture. Null without the module, or before the view has reached the screen - there is\n   * no camera to take it with yet.\n   */\n  async takePicture(options: PictureOptions = {}): Promise<CameraPicture | null> {\n    const nativeTag = this.engine.tagOf(this.node);\n    if (!this.functions || nativeTag === null) return null;\n    return this.functions.takePicture.call({ nativeTag }, options);\n  }\n}\n"]}

package/dist/clipboard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `Clipboard`, bound to `expo-clipboard`.
+ *
+ * The package's JavaScript is used here rather than the native module, because it does real work:
+ * it carries the event name the change listener subscribes to, and the option defaults each call
+ * expects. `expo-haptics`'s JavaScript adds none of that, which is why `./haptics.ts` skips it.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import * as i0 from "@angular/core";
+/** The slice of `expo-clipboard` this needs. */
+export interface NativeClipboard {
+    getStringAsync(): Promise<string>;
+    setStringAsync(text: string): Promise<boolean>;
+    addClipboardListener(listener: () => void): {
+        remove(): void;
+    };
+}
+/**
+ * `changes` counts pasteboard changes rather than holding the contents, and that is deliberate:
+ * on iOS 16 and later, *reading* the clipboard prompts the user for permission. A signal that
+ * held the text would prompt on every change, including changes made by other apps, which is
+ * both a terrible experience and a good way to have the read denied. So the notification is free
+ * and the read is explicit.
+ *
+ * The listener lives as long as the app does, and is removed when the app is destroyed: a root
+ * service is one per app, not one per process, and an app that is mounted and unmounted - by a
+ * test, a reload, a host embedding it - would otherwise leave one listener behind each time.
+ */
+export declare class Clipboard {
+    /** Overridden in a test to drive the pasteboard without one. */
+    static readonly SOURCE: InjectionToken<NativeClipboard | null>;
+    private readonly native;
+    private readonly count;
+    /** How many times the pasteboard has changed since the app started reading it. */
+    readonly changes: Signal<number>;
+    constructor();
+    /** What is on the clipboard. On iOS 16+ this is what asks the user for permission. */
+    read(): Promise<string>;
+    /** Put text on the clipboard. Resolves once native has it. */
+    write(text: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Clipboard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/dist/clipboard.js

@@ -0,0 +1,60 @@
+/**
+ * `Clipboard`, bound to `expo-clipboard`.
+ *
+ * The package's JavaScript is used here rather than the native module, because it does real work:
+ * it carries the event name the change listener subscribes to, and the option defaults each call
+ * expects. `expo-haptics`'s JavaScript adds none of that, which is why `./haptics.ts` skips it.
+ */
+import { DestroyRef, InjectionToken, Service, inject, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+/**
+ * `changes` counts pasteboard changes rather than holding the contents, and that is deliberate:
+ * on iOS 16 and later, *reading* the clipboard prompts the user for permission. A signal that
+ * held the text would prompt on every change, including changes made by other apps, which is
+ * both a terrible experience and a good way to have the read denied. So the notification is free
+ * and the read is explicit.
+ *
+ * The listener lives as long as the app does, and is removed when the app is destroyed: a root
+ * service is one per app, not one per process, and an app that is mounted and unmounted - by a
+ * test, a reload, a host embedding it - would otherwise leave one listener behind each time.
+ */
+export class Clipboard {
+    /** Overridden in a test to drive the pasteboard without one. */
+    static SOURCE = new InjectionToken('angular-native.clipboardSource', {
+        factory: () => {
+            const expo = expoModule('expo-clipboard', () => require('expo-clipboard'));
+            if (!expo)
+                return null;
+            return {
+                getStringAsync: () => expo.getStringAsync(),
+                setStringAsync: (text) => expo.setStringAsync(text),
+                addClipboardListener: (listener) => expo.addClipboardListener(listener),
+            };
+        },
+    });
+    native = inject(Clipboard.SOURCE);
+    count = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "count" }] : /* istanbul ignore next */ []));
+    /** How many times the pasteboard has changed since the app started reading it. */
+    changes = this.count.asReadonly();
+    constructor() {
+        const listener = this.native?.addClipboardListener(() => this.count.update((n) => n + 1));
+        if (listener)
+            inject(DestroyRef).onDestroy(() => listener.remove());
+    }
+    /** What is on the clipboard. On iOS 16+ this is what asks the user for permission. */
+    read() {
+        return this.native?.getStringAsync() ?? Promise.resolve('');
+    }
+    /** Put text on the clipboard. Resolves once native has it. */
+    async write(text) {
+        await this.native?.setStringAsync(text);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Clipboard, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: Clipboard });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Clipboard, decorators: [{
+            type: Service
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=clipboard.js.map

package/dist/clipboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.js","sourceRoot":"","sources":["../src/clipboard.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AACjG,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;;AASzC;;;;;;;;;;GAUG;AAEH,MAAM,OAAO,SAAS;IACpB,gEAAgE;IAChE,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,gCAAgC,EAChC;QACE,OAAO,EAAE,GAAG,EAAE;YACZ,MAAM,IAAI,GAAG,UAAU,CACrB,gBAAgB,EAChB,GAAG,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAoC,CACnE,CAAC;YACF,IAAI,CAAC,IAAI;gBAAE,OAAO,IAAI,CAAC;YACvB,OAAO;gBACL,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE;gBAC3C,cAAc,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;gBACnD,oBAAoB,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC;aACxE,CAAC;QACJ,CAAC;KACF,CACF,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAClC,KAAK,GAAG,MAAM,CAAC,CAAC;8EAAC,CAAC;IAEnC,kFAAkF;IACzE,OAAO,GAAmB,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;IAE3D;QACE,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC1F,IAAI,QAAQ;YAAE,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,sFAAsF;IACtF,IAAI;QACF,OAAO,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED,8DAA8D;IAC9D,KAAK,CAAC,KAAK,CAAC,IAAY;QACtB,MAAM,IAAI,CAAC,MAAM,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;uGAvCU,SAAS;wGAAT,SAAS;;2FAAT,SAAS;kBADrB,OAAO","sourcesContent":["/**\n * `Clipboard`, bound to `expo-clipboard`.\n *\n * The package's JavaScript is used here rather than the native module, because it does real work:\n * it carries the event name the change listener subscribes to, and the option defaults each call\n * expects. `expo-haptics`'s JavaScript adds none of that, which is why `./haptics.ts` skips it.\n */\nimport { DestroyRef, InjectionToken, Service, inject, signal, type Signal } from '@angular/core';\nimport { expoModule } from './native.ts';\n\n/** The slice of `expo-clipboard` this needs. */\nexport interface NativeClipboard {\n  getStringAsync(): Promise<string>;\n  setStringAsync(text: string): Promise<boolean>;\n  addClipboardListener(listener: () => void): { remove(): void };\n}\n\n/**\n * `changes` counts pasteboard changes rather than holding the contents, and that is deliberate:\n * on iOS 16 and later, *reading* the clipboard prompts the user for permission. A signal that\n * held the text would prompt on every change, including changes made by other apps, which is\n * both a terrible experience and a good way to have the read denied. So the notification is free\n * and the read is explicit.\n *\n * The listener lives as long as the app does, and is removed when the app is destroyed: a root\n * service is one per app, not one per process, and an app that is mounted and unmounted - by a\n * test, a reload, a host embedding it - would otherwise leave one listener behind each time.\n */\n@Service()\nexport class Clipboard {\n  /** Overridden in a test to drive the pasteboard without one. */\n  static readonly SOURCE = new InjectionToken<NativeClipboard | null>(\n    'angular-native.clipboardSource',\n    {\n      factory: () => {\n        const expo = expoModule(\n          'expo-clipboard',\n          () => require('expo-clipboard') as typeof import('expo-clipboard'),\n        );\n        if (!expo) return null;\n        return {\n          getStringAsync: () => expo.getStringAsync(),\n          setStringAsync: (text) => expo.setStringAsync(text),\n          addClipboardListener: (listener) => expo.addClipboardListener(listener),\n        };\n      },\n    },\n  );\n\n  private readonly native = inject(Clipboard.SOURCE);\n  private readonly count = signal(0);\n\n  /** How many times the pasteboard has changed since the app started reading it. */\n  readonly changes: Signal<number> = this.count.asReadonly();\n\n  constructor() {\n    const listener = this.native?.addClipboardListener(() => this.count.update((n) => n + 1));\n    if (listener) inject(DestroyRef).onDestroy(() => listener.remove());\n  }\n\n  /** What is on the clipboard. On iOS 16+ this is what asks the user for permission. */\n  read(): Promise<string> {\n    return this.native?.getStringAsync() ?? Promise.resolve('');\n  }\n\n  /** Put text on the clipboard. Resolves once native has it. */\n  async write(text: string): Promise<void> {\n    await this.native?.setStringAsync(text);\n  }\n}\n"]}

package/dist/community-views.d.ts

@@ -0,0 +1,14 @@
+/** Element name -> the Fabric component name, and the props its React wrapper would default. */
+export declare const NATIVE_VIEWS: Readonly<Record<string, [string, Record<string, unknown>?]>>;
+/**
+ * Register several of the known views by element name.
+ *
+ * ```ts
+ * registerNativeViews('web-view', 'slider');
+ * ```
+ *
+ * Named one at a time rather than all at once on purpose: registering a view for a library the
+ * app has not installed produces an element that commits as nothing, and finding out at startup
+ * which libraries are present is not something JavaScript can do without importing them all.
+ */
+export declare function registerNativeViews(...elements: readonly (keyof typeof NATIVE_VIEWS)[]): void;