@ng-native/expo 0.0.1 → 0.1.1

package/dist/apple-sign-in-button.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apple-sign-in-button.js","sourceRoot":"","sources":["../src/apple-sign-in-button.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;;AAKjD,qDAAqD;AACrD,MAAM,KAAK,GAAoC,EAAE,SAAS,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC;AAC3F,MAAM,MAAM,GAAqC,EAAE,KAAK,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;AAW5F,MAAM,OAAO,iBAAiB;IAC5B,+FAA+F;IACtF,UAAU,GAAG,KAAK,CAAkB,SAAS;mFAAC,CAAC;IACxD,iFAAiF;IACxE,WAAW,GAAG,KAAK,CAAmB,OAAO;oFAAC,CAAC;IAC/C,YAAY,GAAG,KAAK,CAAS,SAAS,oFAAI,SAAS,EAAE,cAAc,GAAG,CAAC;IAChF,gEAAgE;IACvD,WAAW,GAAG,MAAM,EAAQ,CAAC;IAEnB,UAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;mFAAC,CAAC;IACtD,WAAW,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;oFAAC,CAAC;uGAVjE,iBAAiB;2FAAjB,iBAAiB,6pBAPlB,EAAE;;2FAOD,iBAAiB;kBAT7B,SAAS;mBAAC;oBACT,QAAQ,EAAE,sBAAsB;oBAChC,QAAQ,EAAE,EAAE;oBACZ,IAAI,EAAE;wBACJ,cAAc,EAAE,cAAc;wBAC9B,eAAe,EAAE,eAAe;wBAChC,gBAAgB,EAAE,gBAAgB;qBACnC;iBACF","sourcesContent":["/**\n * `<apple-sign-in-button>`: Apple's own Sign in with Apple button, `ASAuthorizationAppleIDButton`,\n * from `expo-apple-authentication`. Apple's guidelines allow a custom button only if it follows\n * their branding rules; this one is approved, localised and accessible as it is.\n *\n * Registered with `registerExpoViews('apple-sign-in-button')`, like the other Expo views. It needs\n * a width and a height to show, and its colour and corners come from `buttonStyle` and\n * `cornerRadius`, not from CSS. Show it only where `AppleSignIn.available()` is true: iOS only.\n *\n * ```html\n * <apple-sign-in-button\n *   class=\"h-12 w-full\"\n *   buttonType=\"continue\"\n *   buttonStyle=\"black\"\n *   cornerRadius=\"12\"\n *   (buttonPress)=\"signIn()\"\n * />\n * ```\n */\nimport { Component, computed, input, output } from '@angular/core';\nimport { optionalNumber } from './transforms.ts';\n\nexport type AppleButtonType = 'sign-in' | 'continue' | 'sign-up';\nexport type AppleButtonStyle = 'white' | 'white-outline' | 'black';\n\n/** Native takes both as the module's enum values. */\nconst TYPES: Record<AppleButtonType, number> = { 'sign-in': 0, continue: 1, 'sign-up': 2 };\nconst STYLES: Record<AppleButtonStyle, number> = { white: 0, 'white-outline': 1, black: 2 };\n\n@Component({\n  selector: 'apple-sign-in-button',\n  template: '',\n  host: {\n    '[buttonType]': 'nativeType()',\n    '[buttonStyle]': 'nativeStyle()',\n    '[cornerRadius]': 'cornerRadius()',\n  },\n})\nexport class AppleSignInButton {\n  /** The button's wording: \"Sign in with Apple\", \"Continue with Apple\", \"Sign up with Apple\". */\n  readonly buttonType = input<AppleButtonType>('sign-in');\n  /** Black on a light background, white or white with an outline on a dark one. */\n  readonly buttonStyle = input<AppleButtonStyle>('black');\n  readonly cornerRadius = input<number>(undefined, { transform: optionalNumber });\n  /** The button was tapped: start `AppleSignIn.signIn()` here. */\n  readonly buttonPress = output<void>();\n\n  protected readonly nativeType = computed(() => TYPES[this.buttonType()]);\n  protected readonly nativeStyle = computed(() => STYLES[this.buttonStyle()]);\n}\n"]}

package/dist/apple-sign-in.d.ts

@@ -0,0 +1,68 @@
+/**
+ * `AppleSignIn`, bound to `expo-apple-authentication`: Sign in with Apple, which the App Store
+ * requires of an app that offers another social sign-in. iOS only; everywhere else, and without
+ * the module installed, `available()` answers false and every call answers null.
+ *
+ * ```ts
+ * import { AppleAuthenticationScope, AppleSignIn } from '@ng-native/expo/apple-sign-in';
+ *
+ * private readonly apple = inject(AppleSignIn);
+ *
+ * async signIn(): Promise<void> {
+ *   const credential = await this.apple.signIn({
+ *     requestedScopes: [AppleAuthenticationScope.FULL_NAME, AppleAuthenticationScope.EMAIL],
+ *   });
+ *   if (credential) await this.session.start(credential.identityToken);
+ * }
+ * ```
+ *
+ * The button Apple's guidelines ask for is `<apple-sign-in-button>`, in
+ * `./apple-sign-in-button.ts`.
+ *
+ * A sign-in the user cancels answers null rather than throwing: closing the sheet is an ordinary
+ * answer, not a failure, and every caller would otherwise have to tell `ERR_REQUEST_CANCELED` apart
+ * from a real error itself.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import type { AppleAuthenticationButtonStyle as ExpoButtonStyle, AppleAuthenticationButtonType as ExpoButtonType, AppleAuthenticationCredential, AppleAuthenticationCredentialState as ExpoCredentialState, AppleAuthenticationScope as ExpoScope } from 'expo-apple-authentication';
+import * as i0 from "@angular/core";
+type Expo = typeof import('expo-apple-authentication');
+/** The module's functions this service calls. The real module is one; a test provides a fake. */
+export type NativeAppleAuthentication = Pick<Expo, 'isAvailableAsync' | 'signInAsync' | 'refreshAsync' | 'signOutAsync' | 'getCredentialStateAsync' | 'formatFullName' | 'addRevokeListener'>;
+type Args<K extends keyof NativeAppleAuthentication> = Parameters<NativeAppleAuthentication[K]>;
+/** What `signIn` asks the user to share. */
+export declare const AppleAuthenticationScope: typeof ExpoScope;
+/** What `credentialState` answers. */
+export declare const AppleAuthenticationCredentialState: typeof ExpoCredentialState;
+/** The button's wording, as native takes it. `<apple-sign-in-button>` takes the names instead. */
+export declare const AppleAuthenticationButtonType: typeof ExpoButtonType;
+/** The button's colours, as native takes them. */
+export declare const AppleAuthenticationButtonStyle: typeof ExpoButtonStyle;
+export declare class AppleSignIn {
+    /** Overridden in a test to sign in without Apple. */
+    static readonly SOURCE: InjectionToken<NativeAppleAuthentication | null>;
+    private readonly native;
+    private readonly revocations;
+    constructor();
+    /** How many times the user has revoked the app's Apple ID credential while it ran. */
+    readonly revoked: Signal<number>;
+    /** Whether Sign in with Apple can be offered: iOS 13 and later, with the module installed. */
+    available(): Promise<boolean>;
+    /**
+     * Shows Apple's sign-in sheet. The name and email in the credential are only there the first
+     * time a user signs in to the app, so store them then. Null when the user cancels, or without
+     * the module.
+     */
+    signIn(...options: Args<'signInAsync'>): Promise<AppleAuthenticationCredential | null>;
+    /** A fresh credential for a user already signed in. Null without the module. */
+    refresh(...options: Args<'refreshAsync'>): Promise<AppleAuthenticationCredential | null>;
+    /** Signs the user out with Apple. Null without the module. */
+    signOut(...options: Args<'signOutAsync'>): Promise<AppleAuthenticationCredential | null>;
+    /** Whether a user's credential is still authorised, for a check at launch. Null without the module. */
+    credentialState(user: string): Promise<ExpoCredentialState | null>;
+    /** A credential's name, formatted for the user's locale. Empty without the module. */
+    formatName(...name: Args<'formatFullName'>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppleSignIn, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export { AppleSignInButton, type AppleButtonStyle, type AppleButtonType, } from './apple-sign-in-button.ts';

package/dist/apple-sign-in.js

@@ -0,0 +1,120 @@
+/**
+ * `AppleSignIn`, bound to `expo-apple-authentication`: Sign in with Apple, which the App Store
+ * requires of an app that offers another social sign-in. iOS only; everywhere else, and without
+ * the module installed, `available()` answers false and every call answers null.
+ *
+ * ```ts
+ * import { AppleAuthenticationScope, AppleSignIn } from '@ng-native/expo/apple-sign-in';
+ *
+ * private readonly apple = inject(AppleSignIn);
+ *
+ * async signIn(): Promise<void> {
+ *   const credential = await this.apple.signIn({
+ *     requestedScopes: [AppleAuthenticationScope.FULL_NAME, AppleAuthenticationScope.EMAIL],
+ *   });
+ *   if (credential) await this.session.start(credential.identityToken);
+ * }
+ * ```
+ *
+ * The button Apple's guidelines ask for is `<apple-sign-in-button>`, in
+ * `./apple-sign-in-button.ts`.
+ *
+ * A sign-in the user cancels answers null rather than throwing: closing the sheet is an ordinary
+ * answer, not a failure, and every caller would otherwise have to tell `ERR_REQUEST_CANCELED` apart
+ * from a real error itself.
+ */
+import { DestroyRef, InjectionToken, Service, inject, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+/*
+ * The module's enums, as plain numbers typed as the enums themselves. Importing an enum from the
+ * module loads the module, which a test in Node cannot; these are the same values, so either is
+ * accepted wherever the module's types are.
+ */
+/** What `signIn` asks the user to share. */
+export const AppleAuthenticationScope = {
+    FULL_NAME: 0,
+    EMAIL: 1,
+};
+/** What `credentialState` answers. */
+export const AppleAuthenticationCredentialState = {
+    REVOKED: 0,
+    AUTHORIZED: 1,
+    NOT_FOUND: 2,
+    TRANSFERRED: 3,
+};
+/** The button's wording, as native takes it. `<apple-sign-in-button>` takes the names instead. */
+export const AppleAuthenticationButtonType = {
+    SIGN_IN: 0,
+    CONTINUE: 1,
+    SIGN_UP: 2,
+};
+/** The button's colours, as native takes them. */
+export const AppleAuthenticationButtonStyle = {
+    WHITE: 0,
+    WHITE_OUTLINE: 1,
+    BLACK: 2,
+};
+export class AppleSignIn {
+    /** Overridden in a test to sign in without Apple. */
+    static SOURCE = new InjectionToken('angular-native.appleSignInSource', {
+        factory: () => expoModule('expo-apple-authentication', () => require('expo-apple-authentication'), ['ios']),
+    });
+    native = inject(AppleSignIn.SOURCE);
+    revocations = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "revocations" }] : /* istanbul ignore next */ []));
+    constructor() {
+        if (!this.native)
+            return;
+        // The user can revoke the app's access in Settings while it runs; the session it signed in
+        // with is then no longer theirs to use.
+        const subscription = this.native.addRevokeListener(() => this.revocations.update((count) => count + 1));
+        inject(DestroyRef).onDestroy(() => subscription.remove());
+    }
+    /** How many times the user has revoked the app's Apple ID credential while it ran. */
+    revoked = this.revocations.asReadonly();
+    /** Whether Sign in with Apple can be offered: iOS 13 and later, with the module installed. */
+    async available() {
+        return (await this.native?.isAvailableAsync()) ?? false;
+    }
+    /**
+     * Shows Apple's sign-in sheet. The name and email in the credential are only there the first
+     * time a user signs in to the app, so store them then. Null when the user cancels, or without
+     * the module.
+     */
+    async signIn(...options) {
+        if (!this.native)
+            return null;
+        try {
+            return await this.native.signInAsync(...options);
+        }
+        catch (error) {
+            if (error?.code === 'ERR_REQUEST_CANCELED')
+                return null;
+            throw error;
+        }
+    }
+    /** A fresh credential for a user already signed in. Null without the module. */
+    async refresh(...options) {
+        return (await this.native?.refreshAsync(...options)) ?? null;
+    }
+    /** Signs the user out with Apple. Null without the module. */
+    async signOut(...options) {
+        return (await this.native?.signOutAsync(...options)) ?? null;
+    }
+    /** Whether a user's credential is still authorised, for a check at launch. Null without the module. */
+    async credentialState(user) {
+        return (await this.native?.getCredentialStateAsync(user)) ?? null;
+    }
+    /** A credential's name, formatted for the user's locale. Empty without the module. */
+    formatName(...name) {
+        return this.native?.formatFullName(...name) ?? '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: AppleSignIn, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: AppleSignIn });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: AppleSignIn, decorators: [{
+            type: Service
+        }], ctorParameters: () => [] });
+export { AppleSignInButton, } from "./apple-sign-in-button.js";
+//# sourceMappingURL=apple-sign-in.js.map

package/dist/apple-sign-in.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apple-sign-in.js","sourceRoot":"","sources":["../src/apple-sign-in.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `AppleSignIn`, bound to `expo-apple-authentication`: Sign in with Apple, which the App Store\n * requires of an app that offers another social sign-in. iOS only; everywhere else, and without\n * the module installed, `available()` answers false and every call answers null.\n *\n * ```ts\n * import { AppleAuthenticationScope, AppleSignIn } from '@ng-native/expo/apple-sign-in';\n *\n * private readonly apple = inject(AppleSignIn);\n *\n * async signIn(): Promise<void> {\n *   const credential = await this.apple.signIn({\n *     requestedScopes: [AppleAuthenticationScope.FULL_NAME, AppleAuthenticationScope.EMAIL],\n *   });\n *   if (credential) await this.session.start(credential.identityToken);\n * }\n * ```\n *\n * The button Apple's guidelines ask for is `<apple-sign-in-button>`, in\n * `./apple-sign-in-button.ts`.\n *\n * A sign-in the user cancels answers null rather than throwing: closing the sheet is an ordinary\n * answer, not a failure, and every caller would otherwise have to tell `ERR_REQUEST_CANCELED` apart\n * from a real error itself.\n */\nimport { DestroyRef, InjectionToken, Service, inject, signal, type Signal } from '@angular/core';\nimport type {\n  AppleAuthenticationButtonStyle as ExpoButtonStyle,\n  AppleAuthenticationButtonType as ExpoButtonType,\n  AppleAuthenticationCredential,\n  AppleAuthenticationCredentialState as ExpoCredentialState,\n  AppleAuthenticationScope as ExpoScope,\n} from 'expo-apple-authentication';\nimport { expoModule } from './native.ts';\n\ntype Expo = typeof import('expo-apple-authentication');\n\n/** The module's functions this service calls. The real module is one; a test provides a fake. */\nexport type NativeAppleAuthentication = Pick<\n  Expo,\n  | 'isAvailableAsync'\n  | 'signInAsync'\n  | 'refreshAsync'\n  | 'signOutAsync'\n  | 'getCredentialStateAsync'\n  | 'formatFullName'\n  | 'addRevokeListener'\n>;\n\ntype Args<K extends keyof NativeAppleAuthentication> = Parameters<NativeAppleAuthentication[K]>;\n\n/*\n * The module's enums, as plain numbers typed as the enums themselves. Importing an enum from the\n * module loads the module, which a test in Node cannot; these are the same values, so either is\n * accepted wherever the module's types are.\n */\n\n/** What `signIn` asks the user to share. */\nexport const AppleAuthenticationScope = {\n  FULL_NAME: 0,\n  EMAIL: 1,\n} as unknown as typeof ExpoScope;\n\n/** What `credentialState` answers. */\nexport const AppleAuthenticationCredentialState = {\n  REVOKED: 0,\n  AUTHORIZED: 1,\n  NOT_FOUND: 2,\n  TRANSFERRED: 3,\n} as unknown as typeof ExpoCredentialState;\n\n/** The button's wording, as native takes it. `<apple-sign-in-button>` takes the names instead. */\nexport const AppleAuthenticationButtonType = {\n  SIGN_IN: 0,\n  CONTINUE: 1,\n  SIGN_UP: 2,\n} as unknown as typeof ExpoButtonType;\n\n/** The button's colours, as native takes them. */\nexport const AppleAuthenticationButtonStyle = {\n  WHITE: 0,\n  WHITE_OUTLINE: 1,\n  BLACK: 2,\n} as unknown as typeof ExpoButtonStyle;\n\n@Service()\nexport class AppleSignIn {\n  /** Overridden in a test to sign in without Apple. */\n  static readonly SOURCE = new InjectionToken<NativeAppleAuthentication | null>(\n    'angular-native.appleSignInSource',\n    {\n      factory: () =>\n        expoModule(\n          'expo-apple-authentication',\n          () => require('expo-apple-authentication') as Expo,\n          ['ios'],\n        ),\n    },\n  );\n\n  private readonly native = inject(AppleSignIn.SOURCE);\n  private readonly revocations = signal(0);\n\n  constructor() {\n    if (!this.native) return;\n    // The user can revoke the app's access in Settings while it runs; the session it signed in\n    // with is then no longer theirs to use.\n    const subscription = this.native.addRevokeListener(() =>\n      this.revocations.update((count) => count + 1),\n    );\n    inject(DestroyRef).onDestroy(() => subscription.remove());\n  }\n\n  /** How many times the user has revoked the app's Apple ID credential while it ran. */\n  readonly revoked: Signal<number> = this.revocations.asReadonly();\n\n  /** Whether Sign in with Apple can be offered: iOS 13 and later, with the module installed. */\n  async available(): Promise<boolean> {\n    return (await this.native?.isAvailableAsync()) ?? false;\n  }\n\n  /**\n   * Shows Apple's sign-in sheet. The name and email in the credential are only there the first\n   * time a user signs in to the app, so store them then. Null when the user cancels, or without\n   * the module.\n   */\n  async signIn(...options: Args<'signInAsync'>): Promise<AppleAuthenticationCredential | null> {\n    if (!this.native) return null;\n    try {\n      return await this.native.signInAsync(...options);\n    } catch (error) {\n      if ((error as { code?: unknown } | null)?.code === 'ERR_REQUEST_CANCELED') return null;\n      throw error;\n    }\n  }\n\n  /** A fresh credential for a user already signed in. Null without the module. */\n  async refresh(...options: Args<'refreshAsync'>): Promise<AppleAuthenticationCredential | null> {\n    return (await this.native?.refreshAsync(...options)) ?? null;\n  }\n\n  /** Signs the user out with Apple. Null without the module. */\n  async signOut(...options: Args<'signOutAsync'>): Promise<AppleAuthenticationCredential | null> {\n    return (await this.native?.signOutAsync(...options)) ?? null;\n  }\n\n  /** Whether a user's credential is still authorised, for a check at launch. Null without the module. */\n  async credentialState(user: string): Promise<ExpoCredentialState | null> {\n    return (await this.native?.getCredentialStateAsync(user)) ?? null;\n  }\n\n  /** A credential's name, formatted for the user's locale. Empty without the module. */\n  formatName(...name: Args<'formatFullName'>): string {\n    return this.native?.formatFullName(...name) ?? '';\n  }\n}\n\nexport {\n  AppleSignInButton,\n  type AppleButtonStyle,\n  type AppleButtonType,\n} from './apple-sign-in-button.ts';\n"]}

package/dist/assets.d.ts

@@ -0,0 +1,24 @@
+import { type Injector, type ResourceRef } from '@angular/core';
+/** What `require('./x.png')` becomes, and what a downloaded asset knows about itself. */
+export interface AssetLike {
+    readonly uri: string;
+    readonly width: number | null;
+    readonly height: number | null;
+}
+export interface NativeAssets {
+    load(modules: readonly (number | string)[]): Promise<readonly AssetLike[]>;
+}
+/**
+ * The modules, downloaded, as a resource.
+ *
+ * `modules` is reactive: a signal read inside it re-runs the load, which is what a screen showing
+ * one of several pictures wants. `value()` is undefined until the first load resolves, and a
+ * failure lands in `error()` rather than being thrown at a caller who has nothing to do with it.
+ */
+export declare function assetResource(native: NativeAssets | null, modules: () => readonly (number | string)[], options?: {
+    injector?: Injector;
+}): ResourceRef<readonly AssetLike[] | undefined>;
+/** Download the modules the reactive `modules` function asks for. Created in an injection context. */
+export declare function assets(modules: () => readonly (number | string)[], options?: {
+    injector?: Injector;
+}): ResourceRef<readonly AssetLike[] | undefined>;

package/dist/assets.js

@@ -0,0 +1,47 @@
+/**
+ * `assets()`, bound to `expo-asset`. Images downloaded before they are needed.
+ *
+ * ```ts
+ * protected readonly hero = assets(() => [require('./hero.png')]);
+ *
+ * // <image [source]="hero.value()?.[0]" />
+ * // @if (hero.isLoading()) { <skeleton /> }
+ * ```
+ *
+ * `useAssets()` is a hook around `Asset.loadAsync`, which is already a plain promise - so what is
+ * worth having is not a wrapper but the reason the hook exists: a screen that shows an image
+ * bundled with the app still has to wait for it the first time, and a splash screen or a skeleton
+ * is only useful if something says when the wait is over.
+ *
+ * That is `resource()`, exactly. It is per call site for the same reason the hook is: two screens
+ * loading different pictures are two separate waits, and a singleton holding one `loaded` signal
+ * would have the second screen's load answer the first's. An app that wants assets warmed before
+ * there is an injector at all calls `Asset.loadAsync` itself - there is nothing here to add.
+ */
+import { expoModule } from "./native.js";
+import { resource } from '@angular/core';
+/**
+ * The modules, downloaded, as a resource.
+ *
+ * `modules` is reactive: a signal read inside it re-runs the load, which is what a screen showing
+ * one of several pictures wants. `value()` is undefined until the first load resolves, and a
+ * failure lands in `error()` rather than being thrown at a caller who has nothing to do with it.
+ */
+export function assetResource(native, modules, options = {}) {
+    return resource({
+        params: modules,
+        loader: ({ params }) => native?.load(params) ?? Promise.resolve([]),
+        injector: options.injector,
+    });
+}
+function expoAssets() {
+    const expo = expoModule('expo-asset', () => require('expo-asset'));
+    if (!expo)
+        return null;
+    return { load: async (modules) => expo.Asset.loadAsync(modules) };
+}
+/** Download the modules the reactive `modules` function asks for. Created in an injection context. */
+export function assets(modules, options = {}) {
+    return assetResource(expoAssets(), modules, options);
+}
+//# sourceMappingURL=assets.js.map

package/dist/assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.js","sourceRoot":"","sources":["../src/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,QAAQ,EAAmC,MAAM,eAAe,CAAC;AAa1E;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAC3B,MAA2B,EAC3B,OAA2C,EAC3C,UAAmC,EAAE;IAErC,OAAO,QAAQ,CAAC;QACd,MAAM,EAAE,OAAO;QACf,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACnE,QAAQ,EAAE,OAAO,CAAC,QAAQ;KAC3B,CAAC,CAAC;AACL,CAAC;AAED,SAAS,UAAU;IACjB,MAAM,IAAI,GAAG,UAAU,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,YAAY,CAAgC,CAAC,CAAC;IAClG,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACvB,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,OAA8B,CAAC,EAAE,CAAC;AAC3F,CAAC;AAED,sGAAsG;AACtG,MAAM,UAAU,MAAM,CACpB,OAA2C,EAC3C,UAAmC,EAAE;IAErC,OAAO,aAAa,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC","sourcesContent":["/**\n * `assets()`, bound to `expo-asset`. Images downloaded before they are needed.\n *\n * ```ts\n * protected readonly hero = assets(() => [require('./hero.png')]);\n *\n * // <image [source]=\"hero.value()?.[0]\" />\n * // @if (hero.isLoading()) { <skeleton /> }\n * ```\n *\n * `useAssets()` is a hook around `Asset.loadAsync`, which is already a plain promise - so what is\n * worth having is not a wrapper but the reason the hook exists: a screen that shows an image\n * bundled with the app still has to wait for it the first time, and a splash screen or a skeleton\n * is only useful if something says when the wait is over.\n *\n * That is `resource()`, exactly. It is per call site for the same reason the hook is: two screens\n * loading different pictures are two separate waits, and a singleton holding one `loaded` signal\n * would have the second screen's load answer the first's. An app that wants assets warmed before\n * there is an injector at all calls `Asset.loadAsync` itself - there is nothing here to add.\n */\nimport { expoModule } from './native.ts';\n\nimport { resource, type Injector, type ResourceRef } from '@angular/core';\n\n/** What `require('./x.png')` becomes, and what a downloaded asset knows about itself. */\nexport interface AssetLike {\n  readonly uri: string;\n  readonly width: number | null;\n  readonly height: number | null;\n}\n\nexport interface NativeAssets {\n  load(modules: readonly (number | string)[]): Promise<readonly AssetLike[]>;\n}\n\n/**\n * The modules, downloaded, as a resource.\n *\n * `modules` is reactive: a signal read inside it re-runs the load, which is what a screen showing\n * one of several pictures wants. `value()` is undefined until the first load resolves, and a\n * failure lands in `error()` rather than being thrown at a caller who has nothing to do with it.\n */\nexport function assetResource(\n  native: NativeAssets | null,\n  modules: () => readonly (number | string)[],\n  options: { injector?: Injector } = {},\n): ResourceRef<readonly AssetLike[] | undefined> {\n  return resource({\n    params: modules,\n    loader: ({ params }) => native?.load(params) ?? Promise.resolve([]),\n    injector: options.injector,\n  });\n}\n\nfunction expoAssets(): NativeAssets | null {\n  const expo = expoModule('expo-asset', () => require('expo-asset') as typeof import('expo-asset'));\n  if (!expo) return null;\n  return { load: async (modules) => expo.Asset.loadAsync(modules as number[] | string[]) };\n}\n\n/** Download the modules the reactive `modules` function asks for. Created in an injection context. */\nexport function assets(\n  modules: () => readonly (number | string)[],\n  options: { injector?: Injector } = {},\n): ResourceRef<readonly AssetLike[] | undefined> {\n  return assetResource(expoAssets(), modules, options);\n}\n"]}

package/dist/background-task.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `BackgroundTask`, bound to `expo-background-task`: work the platform runs while the app is in
+ * the background.
+ *
+ * ```ts
+ * // main.ts, at the top level, outside Angular
+ * TaskManager.defineTask('sync', async () => {
+ *   await syncNotes();
+ *   return BackgroundTaskResult.Success;
+ * });
+ *
+ * // anywhere in the app
+ * private readonly tasks = inject(BackgroundTask);
+ * if ((await this.tasks.status()) === BackgroundTaskStatus.Available) {
+ *   await this.tasks.register('sync', { minimumInterval: 60 });
+ * }
+ * ```
+ *
+ * The task itself is defined with `expo-task-manager` at the top level of `main.ts`: the platform
+ * runs it by loading the bundle and evaluating the entry module without bootstrapping Angular, so
+ * it can reach no component and no service from `inject()`. This service is the part the app
+ * does: registering the task, unregistering it, and asking whether the platform will run
+ * background work at all. The platform decides when a registered task runs - WorkManager on
+ * Android, BGTaskScheduler on iOS - and the interval is a minimum, not a schedule.
+ *
+ * Without the module installed, the status is restricted and registering does nothing. The
+ * module's expiration listener is not here: it is for the task's own body, which runs outside
+ * Angular.
+ */
+import { InjectionToken } from '@angular/core';
+import type { BackgroundTaskOptions, BackgroundTaskResult as ExpoResult, BackgroundTaskStatus as ExpoStatus } from 'expo-background-task';
+import * as i0 from "@angular/core";
+type Expo = typeof import('expo-background-task');
+/** The module's functions this service calls. The real module is one; a test provides a fake. */
+export type NativeBackgroundTask = Pick<Expo, 'getStatusAsync' | 'registerTaskAsync' | 'unregisterTaskAsync' | 'triggerTaskWorkerForTestingAsync'>;
+/**
+ * Whether the platform runs background work, as `expo-background-task`'s own enum. Importing the
+ * enum from the module loads the module, which a test in Node cannot; these are the same numbers,
+ * typed as the enum.
+ */
+export declare const BackgroundTaskStatus: typeof ExpoStatus;
+/** What a task defined with `expo-task-manager` answers with, as the module's own enum. */
+export declare const BackgroundTaskResult: typeof ExpoResult;
+export declare class BackgroundTask {
+    /** Overridden in a test to register tasks the platform never runs. */
+    static readonly SOURCE: InjectionToken<NativeBackgroundTask | null>;
+    private readonly native;
+    /** Whether the platform will run background work: available on a device, restricted on the web. */
+    status(): Promise<ExpoStatus>;
+    /**
+     * Asks the platform to run the task named, as defined with `expo-task-manager`, every
+     * `minimumInterval` minutes at the soonest: twelve hours by default, and never less than fifteen
+     * minutes. iOS often ignores a short interval and runs tasks in windows of its own, such as
+     * overnight.
+     */
+    register(name: string, options?: BackgroundTaskOptions): Promise<void>;
+    unregister(name: string): Promise<void>;
+    /**
+     * Runs every registered task now, in a debug build, rather than waiting for the platform. False
+     * in a release build and without the module.
+     */
+    triggerForTesting(): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackgroundTask, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};

package/dist/background-task.js

@@ -0,0 +1,82 @@
+/**
+ * `BackgroundTask`, bound to `expo-background-task`: work the platform runs while the app is in
+ * the background.
+ *
+ * ```ts
+ * // main.ts, at the top level, outside Angular
+ * TaskManager.defineTask('sync', async () => {
+ *   await syncNotes();
+ *   return BackgroundTaskResult.Success;
+ * });
+ *
+ * // anywhere in the app
+ * private readonly tasks = inject(BackgroundTask);
+ * if ((await this.tasks.status()) === BackgroundTaskStatus.Available) {
+ *   await this.tasks.register('sync', { minimumInterval: 60 });
+ * }
+ * ```
+ *
+ * The task itself is defined with `expo-task-manager` at the top level of `main.ts`: the platform
+ * runs it by loading the bundle and evaluating the entry module without bootstrapping Angular, so
+ * it can reach no component and no service from `inject()`. This service is the part the app
+ * does: registering the task, unregistering it, and asking whether the platform will run
+ * background work at all. The platform decides when a registered task runs - WorkManager on
+ * Android, BGTaskScheduler on iOS - and the interval is a minimum, not a schedule.
+ *
+ * Without the module installed, the status is restricted and registering does nothing. The
+ * module's expiration listener is not here: it is for the task's own body, which runs outside
+ * Angular.
+ */
+import { InjectionToken, Service, inject } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+/**
+ * Whether the platform runs background work, as `expo-background-task`'s own enum. Importing the
+ * enum from the module loads the module, which a test in Node cannot; these are the same numbers,
+ * typed as the enum.
+ */
+export const BackgroundTaskStatus = {
+    Restricted: 1,
+    Available: 2,
+};
+/** What a task defined with `expo-task-manager` answers with, as the module's own enum. */
+export const BackgroundTaskResult = {
+    Success: 1,
+    Failed: 2,
+};
+export class BackgroundTask {
+    /** Overridden in a test to register tasks the platform never runs. */
+    static SOURCE = new InjectionToken('angular-native.backgroundTaskSource', {
+        factory: () => expoModule('expo-background-task', () => require('expo-background-task')),
+    });
+    native = inject(BackgroundTask.SOURCE);
+    /** Whether the platform will run background work: available on a device, restricted on the web. */
+    async status() {
+        return (await this.native?.getStatusAsync()) ?? BackgroundTaskStatus.Restricted;
+    }
+    /**
+     * Asks the platform to run the task named, as defined with `expo-task-manager`, every
+     * `minimumInterval` minutes at the soonest: twelve hours by default, and never less than fifteen
+     * minutes. iOS often ignores a short interval and runs tasks in windows of its own, such as
+     * overnight.
+     */
+    async register(name, options) {
+        await this.native?.registerTaskAsync(name, options);
+    }
+    async unregister(name) {
+        await this.native?.unregisterTaskAsync(name);
+    }
+    /**
+     * Runs every registered task now, in a debug build, rather than waiting for the platform. False
+     * in a release build and without the module.
+     */
+    async triggerForTesting() {
+        return (await this.native?.triggerTaskWorkerForTestingAsync()) ?? false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: BackgroundTask, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: BackgroundTask });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: BackgroundTask, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=background-task.js.map

package/dist/background-task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"background-task.js","sourceRoot":"","sources":["../src/background-task.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAMhE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;;AAazC;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,UAAU,EAAE,CAAC;IACb,SAAS,EAAE,CAAC;CACmB,CAAC;AAElC,2FAA2F;AAC3F,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,OAAO,EAAE,CAAC;IACV,MAAM,EAAE,CAAC;CACsB,CAAC;AAGlC,MAAM,OAAO,cAAc;IACzB,sEAAsE;IACtE,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,qCAAqC,EACrC;QACE,OAAO,EAAE,GAAG,EAAE,CACZ,UAAU,CAAC,sBAAsB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,sBAAsB,CAAS,CAAC;KACpF,CACF,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAExD,mGAAmG;IACnG,KAAK,CAAC,MAAM;QACV,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,IAAI,oBAAoB,CAAC,UAAU,CAAC;IAClF,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,CAAC,IAAY,EAAE,OAA+B;QAC1D,MAAM,IAAI,CAAC,MAAM,EAAE,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,IAAY;QAC3B,MAAM,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,iBAAiB;QACrB,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,gCAAgC,EAAE,CAAC,IAAI,KAAK,CAAC;IAC1E,CAAC;uGArCU,cAAc;wGAAd,cAAc;;2FAAd,cAAc;kBAD1B,OAAO","sourcesContent":["/**\n * `BackgroundTask`, bound to `expo-background-task`: work the platform runs while the app is in\n * the background.\n *\n * ```ts\n * // main.ts, at the top level, outside Angular\n * TaskManager.defineTask('sync', async () => {\n *   await syncNotes();\n *   return BackgroundTaskResult.Success;\n * });\n *\n * // anywhere in the app\n * private readonly tasks = inject(BackgroundTask);\n * if ((await this.tasks.status()) === BackgroundTaskStatus.Available) {\n *   await this.tasks.register('sync', { minimumInterval: 60 });\n * }\n * ```\n *\n * The task itself is defined with `expo-task-manager` at the top level of `main.ts`: the platform\n * runs it by loading the bundle and evaluating the entry module without bootstrapping Angular, so\n * it can reach no component and no service from `inject()`. This service is the part the app\n * does: registering the task, unregistering it, and asking whether the platform will run\n * background work at all. The platform decides when a registered task runs - WorkManager on\n * Android, BGTaskScheduler on iOS - and the interval is a minimum, not a schedule.\n *\n * Without the module installed, the status is restricted and registering does nothing. The\n * module's expiration listener is not here: it is for the task's own body, which runs outside\n * Angular.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport type {\n  BackgroundTaskOptions,\n  BackgroundTaskResult as ExpoResult,\n  BackgroundTaskStatus as ExpoStatus,\n} from 'expo-background-task';\nimport { expoModule } from './native.ts';\n\ntype Expo = typeof import('expo-background-task');\n\n/** The module's functions this service calls. The real module is one; a test provides a fake. */\nexport type NativeBackgroundTask = Pick<\n  Expo,\n  | 'getStatusAsync'\n  | 'registerTaskAsync'\n  | 'unregisterTaskAsync'\n  | 'triggerTaskWorkerForTestingAsync'\n>;\n\n/**\n * Whether the platform runs background work, as `expo-background-task`'s own enum. Importing the\n * enum from the module loads the module, which a test in Node cannot; these are the same numbers,\n * typed as the enum.\n */\nexport const BackgroundTaskStatus = {\n  Restricted: 1,\n  Available: 2,\n} as unknown as typeof ExpoStatus;\n\n/** What a task defined with `expo-task-manager` answers with, as the module's own enum. */\nexport const BackgroundTaskResult = {\n  Success: 1,\n  Failed: 2,\n} as unknown as typeof ExpoResult;\n\n@Service()\nexport class BackgroundTask {\n  /** Overridden in a test to register tasks the platform never runs. */\n  static readonly SOURCE = new InjectionToken<NativeBackgroundTask | null>(\n    'angular-native.backgroundTaskSource',\n    {\n      factory: () =>\n        expoModule('expo-background-task', () => require('expo-background-task') as Expo),\n    },\n  );\n\n  private readonly native = inject(BackgroundTask.SOURCE);\n\n  /** Whether the platform will run background work: available on a device, restricted on the web. */\n  async status(): Promise<ExpoStatus> {\n    return (await this.native?.getStatusAsync()) ?? BackgroundTaskStatus.Restricted;\n  }\n\n  /**\n   * Asks the platform to run the task named, as defined with `expo-task-manager`, every\n   * `minimumInterval` minutes at the soonest: twelve hours by default, and never less than fifteen\n   * minutes. iOS often ignores a short interval and runs tasks in windows of its own, such as\n   * overnight.\n   */\n  async register(name: string, options?: BackgroundTaskOptions): Promise<void> {\n    await this.native?.registerTaskAsync(name, options);\n  }\n\n  async unregister(name: string): Promise<void> {\n    await this.native?.unregisterTaskAsync(name);\n  }\n\n  /**\n   * Runs every registered task now, in a debug build, rather than waiting for the platform. False\n   * in a release build and without the module.\n   */\n  async triggerForTesting(): Promise<boolean> {\n    return (await this.native?.triggerTaskWorkerForTestingAsync()) ?? false;\n  }\n}\n"]}

package/dist/battery.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `Battery`, bound to `expo-battery`. For the work an app should not be doing on 5%.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import { type Observed } from './observed.ts';
+import * as i0 from "@angular/core";
+/** What the battery is doing. `unknown` is a real answer on a simulator. */
+export type BatteryState = 'unknown' | 'unplugged' | 'charging' | 'full';
+export interface BatterySources {
+    level: Observed<number> | null;
+    state: Observed<BatteryState> | null;
+    saving: Observed<boolean> | null;
+}
+export declare class Battery {
+    /** Overridden in a test to drain a battery that is not there. */
+    static readonly SOURCE: InjectionToken<BatterySources>;
+    private readonly sources;
+    private readonly reported;
+    /**
+     * Nought to one. One until the platform says otherwise: an app should not open dimmed.
+     *
+     * A negative reading is not a level. iOS answers `-1` where the battery level is unavailable -
+     * every simulator, and a device that will not say - and Expo passes it through. Taken at face
+     * value it is below every threshold an app has, so `low` is true and an app starts shedding
+     * work on the one device that has no battery to save.
+     */
+    readonly level: Signal<number>;
+    /** Whether the platform will say. False on a simulator, and on a device that answers -1. */
+    readonly known: Signal<boolean>;
+    readonly state: Signal<BatteryState>;
+    /**
+     * Low Power Mode on iOS, Battery Saver on Android. The signal to skip the background refresh,
+     * drop the frame rate of a decoration, or stop prefetching.
+     */
+    readonly saving: Signal<boolean>;
+    readonly charging: Signal<boolean>;
+    /**
+     * Under a fifth and not charging: the point at which an app should start doing less.
+     *
+     * False whenever the level is unknown. "I cannot tell" and "almost flat" are not the same
+     * answer, and only one of them is a reason to degrade.
+     */
+    readonly low: Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Battery, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/dist/battery.js

@@ -0,0 +1,76 @@
+/**
+ * `Battery`, bound to `expo-battery`. For the work an app should not be doing on 5%.
+ */
+import { InjectionToken, Service, computed, inject } from '@angular/core';
+import { observed, observedFrom } from "./observed.js";
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+const NOTHING = { level: null, state: null, saving: null };
+export class Battery {
+    /** Overridden in a test to drain a battery that is not there. */
+    static SOURCE = new InjectionToken('angular-native.batterySource', {
+        factory: () => {
+            const expo = expoModule('expo-battery', () => require('expo-battery'));
+            if (!expo)
+                return NOTHING;
+            /**
+             * Expo's states are numbers, and one of them is Android-only.
+             *
+             * `NOT_CHARGING` means plugged in and holding, which for every purpose an app has is
+             * charging: the battery is not going down.
+             */
+            const STATES = {
+                [expo.BatteryState.UNKNOWN]: 'unknown',
+                [expo.BatteryState.UNPLUGGED]: 'unplugged',
+                [expo.BatteryState.CHARGING]: 'charging',
+                [expo.BatteryState.FULL]: 'full',
+                [expo.BatteryState.NOT_CHARGING]: 'full',
+            };
+            return {
+                level: observedFrom(() => expo.getBatteryLevelAsync(), (listener) => expo.addBatteryLevelListener(({ batteryLevel }) => listener(batteryLevel))),
+                state: observedFrom(async () => STATES[await expo.getBatteryStateAsync()] ?? 'unknown', (listener) => expo.addBatteryStateListener(({ batteryState }) => listener(STATES[batteryState] ?? 'unknown'))),
+                saving: observedFrom(() => expo.isLowPowerModeEnabledAsync(), (listener) => expo.addLowPowerModeListener(({ lowPowerMode }) => listener(lowPowerMode))),
+            };
+        },
+    });
+    sources = inject(Battery.SOURCE);
+    reported = observed(this.sources.level, 1);
+    /**
+     * Nought to one. One until the platform says otherwise: an app should not open dimmed.
+     *
+     * A negative reading is not a level. iOS answers `-1` where the battery level is unavailable -
+     * every simulator, and a device that will not say - and Expo passes it through. Taken at face
+     * value it is below every threshold an app has, so `low` is true and an app starts shedding
+     * work on the one device that has no battery to save.
+     */
+    level = computed(() => {
+        const level = this.reported();
+        return level < 0 ? 1 : level;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "level" }] : /* istanbul ignore next */ []));
+    /** Whether the platform will say. False on a simulator, and on a device that answers -1. */
+    known = computed(() => this.reported() >= 0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "known" }] : /* istanbul ignore next */ []));
+    state = observed(this.sources.state, 'unknown');
+    /**
+     * Low Power Mode on iOS, Battery Saver on Android. The signal to skip the background refresh,
+     * drop the frame rate of a decoration, or stop prefetching.
+     */
+    saving = observed(this.sources.saving, false);
+    charging = computed(() => this.state() === 'charging' || this.state() === 'full', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "charging" }] : /* istanbul ignore next */ []));
+    /**
+     * Under a fifth and not charging: the point at which an app should start doing less.
+     *
+     * False whenever the level is unknown. "I cannot tell" and "almost flat" are not the same
+     * answer, and only one of them is a reason to degrade.
+     */
+    low = computed(() => this.known() && this.level() <= 0.2 && !this.charging(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "low" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Battery, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: Battery });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Battery, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=battery.js.map

package/dist/battery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"battery.js","sourceRoot":"","sources":["../src/battery.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `Battery`, bound to `expo-battery`. For the work an app should not be doing on 5%.\n */\nimport { InjectionToken, Service, computed, inject, type Signal } from '@angular/core';\nimport { observed, observedFrom, type Observed } from './observed.ts';\nimport { expoModule } from './native.ts';\n\n/** What the battery is doing. `unknown` is a real answer on a simulator. */\nexport type BatteryState = 'unknown' | 'unplugged' | 'charging' | 'full';\n\nexport interface BatterySources {\n  level: Observed<number> | null;\n  state: Observed<BatteryState> | null;\n  saving: Observed<boolean> | null;\n}\n\nconst NOTHING: BatterySources = { level: null, state: null, saving: null };\n\n@Service()\nexport class Battery {\n  /** Overridden in a test to drain a battery that is not there. */\n  static readonly SOURCE = new InjectionToken<BatterySources>('angular-native.batterySource', {\n    factory: () => {\n      const expo = expoModule(\n        'expo-battery',\n        () => require('expo-battery') as typeof import('expo-battery'),\n      );\n      if (!expo) return NOTHING;\n\n      /**\n       * Expo's states are numbers, and one of them is Android-only.\n       *\n       * `NOT_CHARGING` means plugged in and holding, which for every purpose an app has is\n       * charging: the battery is not going down.\n       */\n      const STATES: Record<number, BatteryState> = {\n        [expo.BatteryState.UNKNOWN]: 'unknown',\n        [expo.BatteryState.UNPLUGGED]: 'unplugged',\n        [expo.BatteryState.CHARGING]: 'charging',\n        [expo.BatteryState.FULL]: 'full',\n        [expo.BatteryState.NOT_CHARGING]: 'full',\n      };\n\n      return {\n        level: observedFrom(\n          () => expo.getBatteryLevelAsync(),\n          (listener) => expo.addBatteryLevelListener(({ batteryLevel }) => listener(batteryLevel)),\n        ),\n        state: observedFrom(\n          async () => STATES[await expo.getBatteryStateAsync()] ?? 'unknown',\n          (listener) =>\n            expo.addBatteryStateListener(({ batteryState }) =>\n              listener(STATES[batteryState] ?? 'unknown'),\n            ),\n        ),\n        saving: observedFrom(\n          () => expo.isLowPowerModeEnabledAsync(),\n          (listener) => expo.addLowPowerModeListener(({ lowPowerMode }) => listener(lowPowerMode)),\n        ),\n      };\n    },\n  });\n\n  private readonly sources = inject(Battery.SOURCE);\n  private readonly reported: Signal<number> = observed(this.sources.level, 1);\n\n  /**\n   * Nought to one. One until the platform says otherwise: an app should not open dimmed.\n   *\n   * A negative reading is not a level. iOS answers `-1` where the battery level is unavailable -\n   * every simulator, and a device that will not say - and Expo passes it through. Taken at face\n   * value it is below every threshold an app has, so `low` is true and an app starts shedding\n   * work on the one device that has no battery to save.\n   */\n  readonly level: Signal<number> = computed(() => {\n    const level = this.reported();\n    return level < 0 ? 1 : level;\n  });\n\n  /** Whether the platform will say. False on a simulator, and on a device that answers -1. */\n  readonly known: Signal<boolean> = computed(() => this.reported() >= 0);\n  readonly state: Signal<BatteryState> = observed(this.sources.state, 'unknown');\n  /**\n   * Low Power Mode on iOS, Battery Saver on Android. The signal to skip the background refresh,\n   * drop the frame rate of a decoration, or stop prefetching.\n   */\n  readonly saving: Signal<boolean> = observed(this.sources.saving, false);\n\n  readonly charging: Signal<boolean> = computed(\n    () => this.state() === 'charging' || this.state() === 'full',\n  );\n\n  /**\n   * Under a fifth and not charging: the point at which an app should start doing less.\n   *\n   * False whenever the level is unknown. \"I cannot tell\" and \"almost flat\" are not the same\n   * answer, and only one of them is a reason to degrade.\n   */\n  readonly low: Signal<boolean> = computed(\n    () => this.known() && this.level() <= 0.2 && !this.charging(),\n  );\n}\n"]}