@ng-native/expo 0.0.1 → 0.1.0

package/dist/fonts.js

@@ -0,0 +1,118 @@
+/**
+ * `Fonts`, bound to `expo-font`.
+ *
+ * A font on a phone is not fetched when the text engine first needs it. It has to be registered
+ * with the platform up front, or the first paint is in the fallback face and reflows when the
+ * real one lands - which is why the interesting call here is the one an app makes *before* it
+ * mounts:
+ *
+ * ```ts
+ * import { loadFonts } from '@ng-native/expo/fonts';
+ *
+ * await loadFonts(styleSheetOf(GlobalStyles));
+ * mount(rootTag, App, getFabricUIManager(), { globalStyles: styleSheetOf(GlobalStyles) });
+ * ```
+ *
+ * The class takes its platform rather than injecting it, because that call happens before there
+ * is an injector to inject from. `inject(Fonts)` is for a screen that wants to ask what loaded.
+ *
+ * Unlike the other services here this goes through `expo-font`'s JavaScript rather than its
+ * native module: the module takes descriptors the JS builds out of an asset, and rebuilding them
+ * here would be copying out its internals rather than using it.
+ */
+import { InjectionToken, computed, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+/**
+ * Loading is by family name, which is also all native matches on.
+ *
+ * There is no weight matching on a device: `font-family: Inter` finds the face registered under
+ * exactly that name, and a bold cut is a family of its own. A face that declares a weight is
+ * therefore registered under a composed name as well as its own, so a stylesheet can say
+ * `font-family: Inter-700` and get the file it declared - and a sheet that only ever registers
+ * one weight per family needs to know none of this.
+ */
+export function registrationsFor(faces) {
+    const map = {};
+    for (const face of faces) {
+        map[face.family] ??= face.source;
+        if (face.weight !== undefined)
+            map[`${face.family}-${face.weight}`] = face.source;
+        if (face.style)
+            map[`${face.family}-${face.style}`] = face.source;
+    }
+    return map;
+}
+export function expoFonts() {
+    const expo = expoModule('expo-font', () => require('expo-font'));
+    if (!expo)
+        return null;
+    return {
+        loadAsync: (map) => expo.loadAsync(map),
+        isLoaded: (family) => expo.isLoaded(family),
+        getLoadedFonts: () => expo.getLoadedFonts(),
+    };
+}
+export class FontRegistry {
+    native;
+    /**
+     * Bumped whenever faces are registered.
+     *
+     * The platform's own list is a plain array that changes underneath us, so a template binding to
+     * it would render once and never again - and the one moment it changes is exactly the moment a
+     * screen waiting on a font wants to hear about. This makes both readers reactive without
+     * mirroring the list.
+     */
+    generation = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "generation" }] : /* istanbul ignore next */ []));
+    constructor(native) {
+        this.native = native;
+    }
+    /** Whether `expo-font` is installed at all. Without it a custom face simply never appears. */
+    get available() {
+        return this.native !== null;
+    }
+    /** Every family the platform can currently find, custom or bundled. */
+    families = computed(() => {
+        this.generation();
+        return this.native?.getLoadedFonts() ?? [];
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "families" }] : /* istanbul ignore next */ []));
+    /** Whether a family is registered. Reactive: re-read after a `load` that adds one. */
+    has(family) {
+        this.generation();
+        return this.native?.isLoaded(family) ?? false;
+    }
+    /**
+     * Register every `@font-face` a compiled sheet declares.
+     *
+     * Awaited before `mount` in an app that uses one: text laid out before this resolves is laid
+     * out in the fallback face. Sheets with no faces resolve immediately, so calling it
+     * unconditionally at bootstrap costs nothing.
+     */
+    async loadSheet(...sheets) {
+        const faces = sheets.flatMap((sheet) => [...(sheet?.fonts ?? [])]);
+        if (!faces.length)
+            return;
+        await this.load(registrationsFor(faces));
+    }
+    /** Register faces by name, for a font that did not come from a stylesheet. */
+    async load(map) {
+        if (!this.native)
+            return;
+        await this.native.loadAsync(map);
+        this.generation.update((n) => n + 1);
+    }
+}
+/** Injected where an app wants to ask what is loaded. */
+export const Fonts = new InjectionToken('angular-native.fonts', {
+    factory: () => new FontRegistry(expoFonts()),
+});
+/**
+ * Register every face the given sheets declare, before the app mounts.
+ *
+ * A function rather than a service because that is when it is needed: there is no injector yet.
+ */
+export function loadFonts(...sheets) {
+    return new FontRegistry(expoFonts()).loadSheet(...sheets);
+}
+//# sourceMappingURL=fonts.js.map

package/dist/fonts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fonts.js","sourceRoot":"","sources":["../src/fonts.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `Fonts`, bound to `expo-font`.\n *\n * A font on a phone is not fetched when the text engine first needs it. It has to be registered\n * with the platform up front, or the first paint is in the fallback face and reflows when the\n * real one lands - which is why the interesting call here is the one an app makes *before* it\n * mounts:\n *\n * ```ts\n * import { loadFonts } from '@ng-native/expo/fonts';\n *\n * await loadFonts(styleSheetOf(GlobalStyles));\n * mount(rootTag, App, getFabricUIManager(), { globalStyles: styleSheetOf(GlobalStyles) });\n * ```\n *\n * The class takes its platform rather than injecting it, because that call happens before there\n * is an injector to inject from. `inject(Fonts)` is for a screen that wants to ask what loaded.\n *\n * Unlike the other services here this goes through `expo-font`'s JavaScript rather than its\n * native module: the module takes descriptors the JS builds out of an asset, and rebuilding them\n * here would be copying out its internals rather than using it.\n */\nimport { InjectionToken, computed, signal, type Signal } from '@angular/core';\nimport { expoModule } from './native.ts';\n\n/** A face a stylesheet declared, as the compiler collected it. */\nexport interface FontFace {\n  readonly family: string;\n  /** What `require('./Inter.ttf')` returned: an asset id, or a module the bundler resolved. */\n  readonly source: unknown;\n  readonly weight?: number;\n  readonly style?: string;\n}\n\n/** Just enough of a compiled stylesheet to find the faces in it. */\nexport interface SheetWithFonts {\n  readonly fonts?: readonly FontFace[];\n}\n\n/** The slice of `expo-font` this needs. */\nexport interface NativeFonts {\n  loadAsync(map: Record<string, unknown>): Promise<void>;\n  isLoaded(family: string): boolean;\n  getLoadedFonts(): string[];\n}\n\n/**\n * Loading is by family name, which is also all native matches on.\n *\n * There is no weight matching on a device: `font-family: Inter` finds the face registered under\n * exactly that name, and a bold cut is a family of its own. A face that declares a weight is\n * therefore registered under a composed name as well as its own, so a stylesheet can say\n * `font-family: Inter-700` and get the file it declared - and a sheet that only ever registers\n * one weight per family needs to know none of this.\n */\nexport function registrationsFor(faces: readonly FontFace[]): Record<string, unknown> {\n  const map: Record<string, unknown> = {};\n  for (const face of faces) {\n    map[face.family] ??= face.source;\n    if (face.weight !== undefined) map[`${face.family}-${face.weight}`] = face.source;\n    if (face.style) map[`${face.family}-${face.style}`] = face.source;\n  }\n  return map;\n}\n\nexport function expoFonts(): NativeFonts | null {\n  const expo = expoModule('expo-font', () => require('expo-font') as typeof import('expo-font'));\n  if (!expo) return null;\n  return {\n    loadAsync: (map) => expo.loadAsync(map as Parameters<typeof expo.loadAsync>[0]),\n    isLoaded: (family) => expo.isLoaded(family),\n    getLoadedFonts: () => expo.getLoadedFonts(),\n  };\n}\n\nexport class FontRegistry {\n  private readonly native: NativeFonts | null;\n  /**\n   * Bumped whenever faces are registered.\n   *\n   * The platform's own list is a plain array that changes underneath us, so a template binding to\n   * it would render once and never again - and the one moment it changes is exactly the moment a\n   * screen waiting on a font wants to hear about. This makes both readers reactive without\n   * mirroring the list.\n   */\n  private readonly generation = signal(0);\n\n  constructor(native: NativeFonts | null) {\n    this.native = native;\n  }\n\n  /** Whether `expo-font` is installed at all. Without it a custom face simply never appears. */\n  get available(): boolean {\n    return this.native !== null;\n  }\n\n  /** Every family the platform can currently find, custom or bundled. */\n  readonly families: Signal<readonly string[]> = computed(() => {\n    this.generation();\n    return this.native?.getLoadedFonts() ?? [];\n  });\n\n  /** Whether a family is registered. Reactive: re-read after a `load` that adds one. */\n  has(family: string): boolean {\n    this.generation();\n    return this.native?.isLoaded(family) ?? false;\n  }\n\n  /**\n   * Register every `@font-face` a compiled sheet declares.\n   *\n   * Awaited before `mount` in an app that uses one: text laid out before this resolves is laid\n   * out in the fallback face. Sheets with no faces resolve immediately, so calling it\n   * unconditionally at bootstrap costs nothing.\n   */\n  async loadSheet(...sheets: readonly (SheetWithFonts | null | undefined)[]): Promise<void> {\n    const faces = sheets.flatMap((sheet) => [...(sheet?.fonts ?? [])]);\n    if (!faces.length) return;\n    await this.load(registrationsFor(faces));\n  }\n\n  /** Register faces by name, for a font that did not come from a stylesheet. */\n  async load(map: Record<string, unknown>): Promise<void> {\n    if (!this.native) return;\n    await this.native.loadAsync(map);\n    this.generation.update((n) => n + 1);\n  }\n}\n\n/** Injected where an app wants to ask what is loaded. */\nexport const Fonts = new InjectionToken<FontRegistry>('angular-native.fonts', {\n  factory: () => new FontRegistry(expoFonts()),\n});\nexport type Fonts = FontRegistry;\n\n/**\n * Register every face the given sheets declare, before the app mounts.\n *\n * A function rather than a service because that is when it is needed: there is no injector yet.\n */\nexport function loadFonts(\n  ...sheets: readonly (SheetWithFonts | null | undefined)[]\n): Promise<void> {\n  return new FontRegistry(expoFonts()).loadSheet(...sheets);\n}\n"]}

package/dist/glass.d.ts

@@ -0,0 +1,33 @@
+import * as i0 from "@angular/core";
+export type GlassStyle = 'regular' | 'clear' | 'none';
+/** A style, and whether a change to it animates. */
+export interface GlassEffectStyleConfig {
+    readonly style: GlassStyle;
+    readonly animate?: boolean;
+    /** Seconds. */
+    readonly animationDuration?: number;
+}
+export declare class ExpoGlass {
+    /** `regular` by default; `clear` is more transparent; `none` turns the effect off. */
+    readonly glassEffectStyle: import("@angular/core").InputSignal<GlassStyle | GlassEffectStyleConfig | undefined>;
+    /** A colour the glass is tinted with, usually translucent. */
+    readonly tintColor: import("@angular/core").InputSignal<string | undefined>;
+    /** Reacts to touch, as a control made of glass does. */
+    readonly isInteractive: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** The appearance the glass takes, when it should not follow the app's. */
+    readonly colorScheme: import("@angular/core").InputSignal<"auto" | "light" | "dark" | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpoGlass, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpoGlass, "expo-glass", never, { "glassEffectStyle": { "alias": "glassEffectStyle"; "required": false; "isSignal": true; }; "tintColor": { "alias": "tintColor"; "required": false; "isSignal": true; }; "isInteractive": { "alias": "isInteractive"; "required": false; "isSignal": true; }; "colorScheme": { "alias": "colorScheme"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** Glass views that merge into one another when they come within `spacing` points. */
+export declare class ExpoGlassContainer {
+    readonly spacing: import("@angular/core").InputSignalWithTransform<number | undefined, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpoGlassContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpoGlassContainer, "expo-glass-container", never, { "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * Whether the app renders with Liquid Glass: iOS 26 and later, with `expo-glass-effect`
+ * installed. The user can still reduce transparency in the accessibility settings, which the
+ * platform then honours on its own.
+ */
+export declare function liquidGlassAvailable(): boolean;

package/dist/glass.js

@@ -0,0 +1,72 @@
+/**
+ * `<expo-glass>` and `<expo-glass-container>`: iOS 26's Liquid Glass, from `expo-glass-effect`,
+ * typed so a template is checked against the props. Registered with
+ * `registerExpoViews('expo-glass', 'expo-glass-container')`. Where Liquid Glass is unavailable -
+ * before iOS 26, and on Android - the view renders as a plain view, so a fallback background is the
+ * app's to set; `liquidGlassAvailable()` says which it will be.
+ *
+ * ```html
+ * <expo-glass-container spacing="10">
+ *   <expo-glass class="size-16 rounded-full" glassEffectStyle="clear" isInteractive />
+ *   <expo-glass class="size-16 rounded-full" tintColor="#0a84ff33" />
+ * </expo-glass-container>
+ * ```
+ *
+ * The corners are the element's own `border-radius`, which native reads from the same props.
+ */
+import { Component, input } from '@angular/core';
+import { optionalBoolean, optionalNumber } from "./transforms.js";
+import * as i0 from "@angular/core";
+export class ExpoGlass {
+    /** `regular` by default; `clear` is more transparent; `none` turns the effect off. */
+    glassEffectStyle = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "glassEffectStyle" }] : /* istanbul ignore next */ []));
+    /** A colour the glass is tinted with, usually translucent. */
+    tintColor = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "tintColor" }] : /* istanbul ignore next */ []));
+    /** Reacts to touch, as a control made of glass does. */
+    isInteractive = input(undefined, { ...(ngDevMode ? { debugName: "isInteractive" } : /* istanbul ignore next */ {}), transform: optionalBoolean });
+    /** The appearance the glass takes, when it should not follow the app's. */
+    colorScheme = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "colorScheme" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ExpoGlass, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.2.0", type: ExpoGlass, isStandalone: true, selector: "expo-glass", inputs: { glassEffectStyle: { classPropertyName: "glassEffectStyle", publicName: "glassEffectStyle", isSignal: true, isRequired: false, transformFunction: null }, tintColor: { classPropertyName: "tintColor", publicName: "tintColor", isSignal: true, isRequired: false, transformFunction: null }, isInteractive: { classPropertyName: "isInteractive", publicName: "isInteractive", isSignal: true, isRequired: false, transformFunction: null }, colorScheme: { classPropertyName: "colorScheme", publicName: "colorScheme", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "glassEffectStyle": "glassEffectStyle()", "tintColor": "tintColor()", "isInteractive": "isInteractive()", "colorScheme": "colorScheme()" } }, ngImport: i0, template: '<ng-content />', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ExpoGlass, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'expo-glass',
+                    template: '<ng-content />',
+                    host: {
+                        '[glassEffectStyle]': 'glassEffectStyle()',
+                        '[tintColor]': 'tintColor()',
+                        '[isInteractive]': 'isInteractive()',
+                        '[colorScheme]': 'colorScheme()',
+                    },
+                }]
+        }], propDecorators: { glassEffectStyle: [{ type: i0.Input, args: [{ isSignal: true, alias: "glassEffectStyle", required: false }] }], tintColor: [{ type: i0.Input, args: [{ isSignal: true, alias: "tintColor", required: false }] }], isInteractive: [{ type: i0.Input, args: [{ isSignal: true, alias: "isInteractive", required: false }] }], colorScheme: [{ type: i0.Input, args: [{ isSignal: true, alias: "colorScheme", required: false }] }] } });
+/** Glass views that merge into one another when they come within `spacing` points. */
+export class ExpoGlassContainer {
+    spacing = input(undefined, { ...(ngDevMode ? { debugName: "spacing" } : /* istanbul ignore next */ {}), transform: optionalNumber });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ExpoGlassContainer, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.2.0", type: ExpoGlassContainer, isStandalone: true, selector: "expo-glass-container", inputs: { spacing: { classPropertyName: "spacing", publicName: "spacing", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "spacing": "spacing()" } }, ngImport: i0, template: '<ng-content />', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ExpoGlassContainer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'expo-glass-container',
+                    template: '<ng-content />',
+                    host: { '[spacing]': 'spacing()' },
+                }]
+        }], propDecorators: { spacing: [{ type: i0.Input, args: [{ isSignal: true, alias: "spacing", required: false }] }] } });
+/**
+ * Whether the app renders with Liquid Glass: iOS 26 and later, with `expo-glass-effect`
+ * installed. The user can still reduce transparency in the accessibility settings, which the
+ * platform then honours on its own.
+ */
+export function liquidGlassAvailable() {
+    const modules = globalThis.expo?.modules;
+    const glass = modules?.['ExpoGlassEffect'];
+    return glass?.isLiquidGlassAvailable === true;
+}
+//# sourceMappingURL=glass.js.map

package/dist/glass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glass.js","sourceRoot":"","sources":["../src/glass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;;AAsBlE,MAAM,OAAO,SAAS;IACpB,sFAAsF;IAC7E,gBAAgB,GAAG,KAAK;oGAAuC,CAAC;IACzE,8DAA8D;IACrD,SAAS,GAAG,KAAK;6FAAU,CAAC;IACrC,wDAAwD;IAC/C,aAAa,GAAG,KAAK,CAAU,SAAS,qFAAI,SAAS,EAAE,eAAe,GAAG,CAAC;IACnF,2EAA2E;IAClE,WAAW,GAAG,KAAK;+FAA6B,CAAC;uGAR/C,SAAS;2FAAT,SAAS,6yBARV,gBAAgB;;2FAQf,SAAS;kBAVrB,SAAS;mBAAC;oBACT,QAAQ,EAAE,YAAY;oBACtB,QAAQ,EAAE,gBAAgB;oBAC1B,IAAI,EAAE;wBACJ,oBAAoB,EAAE,oBAAoB;wBAC1C,aAAa,EAAE,aAAa;wBAC5B,iBAAiB,EAAE,iBAAiB;wBACpC,eAAe,EAAE,eAAe;qBACjC;iBACF;;AAYD,sFAAsF;AAMtF,MAAM,OAAO,kBAAkB;IACpB,OAAO,GAAG,KAAK,CAAS,SAAS,+EAAI,SAAS,EAAE,cAAc,GAAG,CAAC;uGADhE,kBAAkB;2FAAlB,kBAAkB,4QAHnB,gBAAgB;;2FAGf,kBAAkB;kBAL9B,SAAS;mBAAC;oBACT,QAAQ,EAAE,sBAAsB;oBAChC,QAAQ,EAAE,gBAAgB;oBAC1B,IAAI,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE;iBACnC;;AAKD;;;;GAIG;AACH,MAAM,UAAU,oBAAoB;IAClC,MAAM,OAAO,GAAI,UAA+D,CAAC,IAAI,EAAE,OAAO,CAAC;IAC/F,MAAM,KAAK,GAAG,OAAO,EAAE,CAAC,iBAAiB,CAAqD,CAAC;IAC/F,OAAO,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC;AAChD,CAAC","sourcesContent":["/**\n * `<expo-glass>` and `<expo-glass-container>`: iOS 26's Liquid Glass, from `expo-glass-effect`,\n * typed so a template is checked against the props. Registered with\n * `registerExpoViews('expo-glass', 'expo-glass-container')`. Where Liquid Glass is unavailable -\n * before iOS 26, and on Android - the view renders as a plain view, so a fallback background is the\n * app's to set; `liquidGlassAvailable()` says which it will be.\n *\n * ```html\n * <expo-glass-container spacing=\"10\">\n *   <expo-glass class=\"size-16 rounded-full\" glassEffectStyle=\"clear\" isInteractive />\n *   <expo-glass class=\"size-16 rounded-full\" tintColor=\"#0a84ff33\" />\n * </expo-glass-container>\n * ```\n *\n * The corners are the element's own `border-radius`, which native reads from the same props.\n */\nimport { Component, input } from '@angular/core';\nimport { optionalBoolean, optionalNumber } from './transforms.ts';\n\nexport type GlassStyle = 'regular' | 'clear' | 'none';\n\n/** A style, and whether a change to it animates. */\nexport interface GlassEffectStyleConfig {\n  readonly style: GlassStyle;\n  readonly animate?: boolean;\n  /** Seconds. */\n  readonly animationDuration?: number;\n}\n\n@Component({\n  selector: 'expo-glass',\n  template: '<ng-content />',\n  host: {\n    '[glassEffectStyle]': 'glassEffectStyle()',\n    '[tintColor]': 'tintColor()',\n    '[isInteractive]': 'isInteractive()',\n    '[colorScheme]': 'colorScheme()',\n  },\n})\nexport class ExpoGlass {\n  /** `regular` by default; `clear` is more transparent; `none` turns the effect off. */\n  readonly glassEffectStyle = input<GlassStyle | GlassEffectStyleConfig>();\n  /** A colour the glass is tinted with, usually translucent. */\n  readonly tintColor = input<string>();\n  /** Reacts to touch, as a control made of glass does. */\n  readonly isInteractive = input<boolean>(undefined, { transform: optionalBoolean });\n  /** The appearance the glass takes, when it should not follow the app's. */\n  readonly colorScheme = input<'auto' | 'light' | 'dark'>();\n}\n\n/** Glass views that merge into one another when they come within `spacing` points. */\n@Component({\n  selector: 'expo-glass-container',\n  template: '<ng-content />',\n  host: { '[spacing]': 'spacing()' },\n})\nexport class ExpoGlassContainer {\n  readonly spacing = input<number>(undefined, { transform: optionalNumber });\n}\n\n/**\n * Whether the app renders with Liquid Glass: iOS 26 and later, with `expo-glass-effect`\n * installed. The user can still reduce transparency in the accessibility settings, which the\n * platform then honours on its own.\n */\nexport function liquidGlassAvailable(): boolean {\n  const modules = (globalThis as { expo?: { modules?: Record<string, unknown> } }).expo?.modules;\n  const glass = modules?.['ExpoGlassEffect'] as { isLiquidGlassAvailable?: unknown } | undefined;\n  return glass?.isLiquidGlassAvailable === true;\n}\n"]}

package/dist/haptics.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `Haptics`, bound to Expo's native module.
+ *
+ * Injected, not imported as functions: `inject(Haptics).impact()`. Nothing needs providing - the
+ * source token carries its own factory, and a service nobody injects is never constructed.
+ *
+ * The native module is used directly rather than through `expo-haptics`'s JavaScript, which adds
+ * one thing: a throw when the module is missing. Asking for it optionally answers the same
+ * question without the throw, and sidesteps the enum its functions take. The package still has
+ * to be installed - that is what links the native side.
+ */
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/** How hard the collision felt. `rigid` and `soft` are iOS 13+. */
+export type ImpactStyle = 'light' | 'medium' | 'heavy' | 'rigid' | 'soft';
+/** What happened, rather than how it felt. iOS plays a distinct pattern for each. */
+export type NotificationType = 'success' | 'warning' | 'error';
+/** The slice of `expo-haptics` this needs. */
+export interface NativeHaptics {
+    impactAsync(style: ImpactStyle): Promise<void>;
+    notificationAsync(type: NotificationType): Promise<void>;
+    selectionAsync(): Promise<void>;
+}
+/**
+ * Every method returns nothing and swallows failures.
+ *
+ * Expo's are all promises, and a caller who does not await one gets an unhandled rejection on a
+ * device with no Taptic Engine, in a simulator, or on an Android build with vibration permission
+ * off - none of which is a reason for anything to go wrong on screen. Nobody awaits a vibration.
+ *
+ * ponytail: silence means a broken haptic looks like a working one. If that ever needs
+ * debugging, log under `__DEV__` rather than making callers handle a rejection.
+ */
+export declare class Haptics {
+    /** Overridden in a test to record feedback that never reaches a Taptic Engine. */
+    static readonly SOURCE: InjectionToken<NativeHaptics | null>;
+    private readonly native;
+    /** Whether the native module is installed at all. */
+    get available(): boolean;
+    /** A collision between interface elements. */
+    impact(style?: ImpactStyle): void;
+    /** A task succeeded or failed. */
+    notify(type: NotificationType): void;
+    /** A selection changed: the lightest of the three. */
+    select(): void;
+    private play;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Haptics, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/dist/haptics.js

@@ -0,0 +1,64 @@
+/**
+ * `Haptics`, bound to Expo's native module.
+ *
+ * Injected, not imported as functions: `inject(Haptics).impact()`. Nothing needs providing - the
+ * source token carries its own factory, and a service nobody injects is never constructed.
+ *
+ * The native module is used directly rather than through `expo-haptics`'s JavaScript, which adds
+ * one thing: a throw when the module is missing. Asking for it optionally answers the same
+ * question without the throw, and sidesteps the enum its functions take. The package still has
+ * to be installed - that is what links the native side.
+ */
+import { InjectionToken, Service, inject } from '@angular/core';
+import { expoModule, optional } from "./native.js";
+import * as i0 from "@angular/core";
+/**
+ * Every method returns nothing and swallows failures.
+ *
+ * Expo's are all promises, and a caller who does not await one gets an unhandled rejection on a
+ * device with no Taptic Engine, in a simulator, or on an Android build with vibration permission
+ * off - none of which is a reason for anything to go wrong on screen. Nobody awaits a vibration.
+ *
+ * ponytail: silence means a broken haptic looks like a working one. If that ever needs
+ * debugging, log under `__DEV__` rather than making callers handle a rejection.
+ */
+export class Haptics {
+    /** Overridden in a test to record feedback that never reaches a Taptic Engine. */
+    static SOURCE = new InjectionToken('angular-native.hapticsSource', {
+        factory: () => {
+            const core = optional(() => require('expo-modules-core'));
+            return expoModule('expo-haptics', () => core?.requireOptionalNativeModule('ExpoHaptics'));
+        },
+    });
+    native = inject(Haptics.SOURCE);
+    /** Whether the native module is installed at all. */
+    get available() {
+        return this.native !== null;
+    }
+    /** A collision between interface elements. */
+    impact(style = 'medium') {
+        this.play(() => this.native?.impactAsync(style));
+    }
+    /** A task succeeded or failed. */
+    notify(type) {
+        this.play(() => this.native?.notificationAsync(type));
+    }
+    /** A selection changed: the lightest of the three. */
+    select() {
+        this.play(() => this.native?.selectionAsync());
+    }
+    play(feedback) {
+        try {
+            void feedback()?.catch(() => { });
+        }
+        catch {
+            // A module that is present but not linked throws synchronously.
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Haptics, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: Haptics });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Haptics, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=haptics.js.map

package/dist/haptics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"haptics.js","sourceRoot":"","sources":["../src/haptics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;;AAenD;;;;;;;;;GASG;AAEH,MAAM,OAAO,OAAO;IAClB,kFAAkF;IAClF,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,8BAA8B,EAC9B;QACE,OAAO,EAAE,GAAG,EAAE;YACZ,MAAM,IAAI,GAAG,QAAQ,CACnB,GAAG,EAAE,CAAC,OAAO,CAAC,mBAAmB,CAAuC,CACzE,CAAC;YACF,OAAO,UAAU,CAAC,cAAc,EAAE,GAAG,EAAE,CACrC,IAAI,EAAE,2BAA2B,CAAgB,aAAa,CAAC,CAChE,CAAC;QACJ,CAAC;KACF,CACF,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAEjD,qDAAqD;IACrD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC;IAC9B,CAAC;IAED,8CAA8C;IAC9C,MAAM,CAAC,QAAqB,QAAQ;QAClC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IACnD,CAAC;IAED,kCAAkC;IAClC,MAAM,CAAC,IAAsB;QAC3B,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,sDAAsD;IACtD,MAAM;QACJ,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC;IACjD,CAAC;IAEO,IAAI,CAAC,QAAyC;QACpD,IAAI,CAAC;YACH,KAAK,QAAQ,EAAE,EAAE,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QACnC,CAAC;QAAC,MAAM,CAAC;YACP,gEAAgE;QAClE,CAAC;IACH,CAAC;uGA5CU,OAAO;wGAAP,OAAO;;2FAAP,OAAO;kBADnB,OAAO","sourcesContent":["/**\n * `Haptics`, bound to Expo's native module.\n *\n * Injected, not imported as functions: `inject(Haptics).impact()`. Nothing needs providing - the\n * source token carries its own factory, and a service nobody injects is never constructed.\n *\n * The native module is used directly rather than through `expo-haptics`'s JavaScript, which adds\n * one thing: a throw when the module is missing. Asking for it optionally answers the same\n * question without the throw, and sidesteps the enum its functions take. The package still has\n * to be installed - that is what links the native side.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport { expoModule, optional } from './native.ts';\n\n/** How hard the collision felt. `rigid` and `soft` are iOS 13+. */\nexport type ImpactStyle = 'light' | 'medium' | 'heavy' | 'rigid' | 'soft';\n\n/** What happened, rather than how it felt. iOS plays a distinct pattern for each. */\nexport type NotificationType = 'success' | 'warning' | 'error';\n\n/** The slice of `expo-haptics` this needs. */\nexport interface NativeHaptics {\n  impactAsync(style: ImpactStyle): Promise<void>;\n  notificationAsync(type: NotificationType): Promise<void>;\n  selectionAsync(): Promise<void>;\n}\n\n/**\n * Every method returns nothing and swallows failures.\n *\n * Expo's are all promises, and a caller who does not await one gets an unhandled rejection on a\n * device with no Taptic Engine, in a simulator, or on an Android build with vibration permission\n * off - none of which is a reason for anything to go wrong on screen. Nobody awaits a vibration.\n *\n * ponytail: silence means a broken haptic looks like a working one. If that ever needs\n * debugging, log under `__DEV__` rather than making callers handle a rejection.\n */\n@Service()\nexport class Haptics {\n  /** Overridden in a test to record feedback that never reaches a Taptic Engine. */\n  static readonly SOURCE = new InjectionToken<NativeHaptics | null>(\n    'angular-native.hapticsSource',\n    {\n      factory: () => {\n        const core = optional(\n          () => require('expo-modules-core') as typeof import('expo-modules-core'),\n        );\n        return expoModule('expo-haptics', () =>\n          core?.requireOptionalNativeModule<NativeHaptics>('ExpoHaptics'),\n        );\n      },\n    },\n  );\n\n  private readonly native = inject(Haptics.SOURCE);\n\n  /** Whether the native module is installed at all. */\n  get available(): boolean {\n    return this.native !== null;\n  }\n\n  /** A collision between interface elements. */\n  impact(style: ImpactStyle = 'medium'): void {\n    this.play(() => this.native?.impactAsync(style));\n  }\n\n  /** A task succeeded or failed. */\n  notify(type: NotificationType): void {\n    this.play(() => this.native?.notificationAsync(type));\n  }\n\n  /** A selection changed: the lightest of the three. */\n  select(): void {\n    this.play(() => this.native?.selectionAsync());\n  }\n\n  private play(feedback: () => Promise<void> | undefined): void {\n    try {\n      void feedback()?.catch(() => {});\n    } catch {\n      // A module that is present but not linked throws synchronously.\n    }\n  }\n}\n"]}

package/dist/image-editor.d.ts

@@ -0,0 +1,62 @@
+/**
+ * `ImageEditor`, bound to `expo-image-manipulator`: resizing, cropping, rotating, flipping and
+ * re-encoding an image file.
+ *
+ * ```ts
+ * import { ImageEditor, SaveFormat } from '@ng-native/expo/image-editor';
+ *
+ * private readonly editor = inject(ImageEditor);
+ *
+ * async thumbnail(uri: string): Promise<string | null> {
+ *   const image = await this.editor.edit(uri, [{ resize: { width: 256 } }], {
+ *     format: SaveFormat.WEBP,
+ *     compress: 0.8,
+ *   });
+ *   return image?.uri ?? null;
+ * }
+ * ```
+ *
+ * `edit()` takes the module's own actions and save options - the shape of its `manipulateAsync`
+ * - and runs them through the module's current contextual API: one context, each action applied
+ * in order, the result rendered and saved to a new file in the cache. The context and the
+ * rendered image are native memory nothing else holds, so both are released once the file is
+ * written, including when it fails. `manipulate()` hands over the module's context itself, for a
+ * caller that chains its own steps and releases it after.
+ *
+ * Without the module installed, `edit()` resolves to null and `manipulate()` is null.
+ */
+import { InjectionToken } from '@angular/core';
+import type { Action, FlipType as ExpoFlipType, ImageManipulatorContext, ImageResult, SaveFormat as ExpoSaveFormat, SaveOptions } from 'expo-image-manipulator';
+import * as i0 from "@angular/core";
+type Expo = typeof import('expo-image-manipulator');
+/** The module's API this service calls. The real module is one; a test provides a fake. */
+export type NativeImageEditor = Pick<Expo, 'ImageManipulator'>;
+/**
+ * The formats an edited image is saved in, as `expo-image-manipulator`'s own enum. Importing the
+ * enum from the module loads the module, which a test in Node cannot; these are the same strings,
+ * typed as the enum.
+ */
+export declare const SaveFormat: typeof ExpoSaveFormat;
+/** The directions an image is flipped in, as the module's own enum. */
+export declare const FlipType: typeof ExpoFlipType;
+export declare class ImageEditor {
+    /** Overridden in a test to edit images without decoding any. */
+    static readonly SOURCE: InjectionToken<NativeImageEditor | null>;
+    private readonly native;
+    /**
+     * Applies each action in order and saves the result as a new file: a JPEG unless `format` says
+     * otherwise, `compress` from 0 to 1, and `base64` to have the contents back as well. Each action
+     * has exactly one key: `resize`, `rotate` (degrees, clockwise), `flip`, `crop`, or on the web
+     * `extent`.
+     */
+    edit(source: string, actions?: readonly Action[], options?: SaveOptions): Promise<ImageResult | null>;
+    /**
+     * The module's own context for a file or data URI, for chaining steps by hand: `resize()`,
+     * `rotate()`, `flip()`, `crop()` and `reset()`, then `renderAsync()`. The caller
+     * releases it, and the image it renders, once done.
+     */
+    manipulate(source: string): ImageManipulatorContext | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageEditor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};

package/dist/image-editor.js

@@ -0,0 +1,101 @@
+/**
+ * `ImageEditor`, bound to `expo-image-manipulator`: resizing, cropping, rotating, flipping and
+ * re-encoding an image file.
+ *
+ * ```ts
+ * import { ImageEditor, SaveFormat } from '@ng-native/expo/image-editor';
+ *
+ * private readonly editor = inject(ImageEditor);
+ *
+ * async thumbnail(uri: string): Promise<string | null> {
+ *   const image = await this.editor.edit(uri, [{ resize: { width: 256 } }], {
+ *     format: SaveFormat.WEBP,
+ *     compress: 0.8,
+ *   });
+ *   return image?.uri ?? null;
+ * }
+ * ```
+ *
+ * `edit()` takes the module's own actions and save options - the shape of its `manipulateAsync`
+ * - and runs them through the module's current contextual API: one context, each action applied
+ * in order, the result rendered and saved to a new file in the cache. The context and the
+ * rendered image are native memory nothing else holds, so both are released once the file is
+ * written, including when it fails. `manipulate()` hands over the module's context itself, for a
+ * caller that chains its own steps and releases it after.
+ *
+ * Without the module installed, `edit()` resolves to null and `manipulate()` is null.
+ */
+import { InjectionToken, Service, inject } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+/**
+ * The formats an edited image is saved in, as `expo-image-manipulator`'s own enum. Importing the
+ * enum from the module loads the module, which a test in Node cannot; these are the same strings,
+ * typed as the enum.
+ */
+export const SaveFormat = {
+    JPEG: 'jpeg',
+    PNG: 'png',
+    WEBP: 'webp',
+};
+/** The directions an image is flipped in, as the module's own enum. */
+export const FlipType = {
+    Vertical: 'vertical',
+    Horizontal: 'horizontal',
+};
+export class ImageEditor {
+    /** Overridden in a test to edit images without decoding any. */
+    static SOURCE = new InjectionToken('angular-native.imageEditorSource', {
+        factory: () => expoModule('expo-image-manipulator', () => require('expo-image-manipulator')),
+    });
+    native = inject(ImageEditor.SOURCE);
+    /**
+     * Applies each action in order and saves the result as a new file: a JPEG unless `format` says
+     * otherwise, `compress` from 0 to 1, and `base64` to have the contents back as well. Each action
+     * has exactly one key: `resize`, `rotate` (degrees, clockwise), `flip`, `crop`, or on the web
+     * `extent`.
+     */
+    async edit(source, actions = [], options = {}) {
+        const context = this.manipulate(source);
+        if (!context)
+            return null;
+        let image;
+        try {
+            for (const action of actions)
+                apply(context, action);
+            image = await context.renderAsync();
+            return await image.saveAsync({ format: SaveFormat.JPEG, ...options });
+        }
+        finally {
+            context.release();
+            image?.release();
+        }
+    }
+    /**
+     * The module's own context for a file or data URI, for chaining steps by hand: `resize()`,
+     * `rotate()`, `flip()`, `crop()` and `reset()`, then `renderAsync()`. The caller
+     * releases it, and the image it renders, once done.
+     */
+    manipulate(source) {
+        return this.native?.ImageManipulator.manipulate(source) ?? null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ImageEditor, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: ImageEditor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ImageEditor, decorators: [{
+            type: Service
+        }] });
+function apply(context, action) {
+    if ('resize' in action)
+        context.resize(action.resize);
+    else if ('rotate' in action)
+        context.rotate(action.rotate);
+    else if ('flip' in action)
+        context.flip(action.flip);
+    else if ('crop' in action)
+        context.crop(action.crop);
+    // The web's context alone has `extent`; elsewhere the action is skipped, as the module skips it.
+    else if ('extent' in action)
+        context.extent?.(action.extent);
+}
+//# sourceMappingURL=image-editor.js.map

package/dist/image-editor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-editor.js","sourceRoot":"","sources":["../src/image-editor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAShE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;;AAOzC;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;CACuB,CAAC;AAEtC,uEAAuE;AACvE,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,QAAQ,EAAE,UAAU;IACpB,UAAU,EAAE,YAAY;CACS,CAAC;AAGpC,MAAM,OAAO,WAAW;IACtB,gEAAgE;IAChE,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,kCAAkC,EAClC;QACE,OAAO,EAAE,GAAG,EAAE,CACZ,UAAU,CAAC,wBAAwB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,wBAAwB,CAAS,CAAC;KACxF,CACF,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAErD;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CACR,MAAc,EACd,UAA6B,EAAE,EAC/B,UAAuB,EAAE;QAEzB,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC;QAC1B,IAAI,KAA8E,CAAC;QACnF,IAAI,CAAC;YACH,KAAK,MAAM,MAAM,IAAI,OAAO;gBAAE,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YACrD,KAAK,GAAG,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC;YACpC,OAAO,MAAM,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QACxE,CAAC;gBAAS,CAAC;YACT,OAAO,CAAC,OAAO,EAAE,CAAC;YAClB,KAAK,EAAE,OAAO,EAAE,CAAC;QACnB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,MAAc;QACvB,OAAO,IAAI,CAAC,MAAM,EAAE,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;IAClE,CAAC;uGA3CU,WAAW;wGAAX,WAAW;;2FAAX,WAAW;kBADvB,OAAO;;AA+CR,SAAS,KAAK,CAAC,OAAgC,EAAE,MAAc;IAC7D,IAAI,QAAQ,IAAI,MAAM;QAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;SACjD,IAAI,QAAQ,IAAI,MAAM;QAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;SACtD,IAAI,MAAM,IAAI,MAAM;QAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;SAChD,IAAI,MAAM,IAAI,MAAM;QAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACrD,iGAAiG;SAC5F,IAAI,QAAQ,IAAI,MAAM;QAAE,OAAO,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAC/D,CAAC","sourcesContent":["/**\n * `ImageEditor`, bound to `expo-image-manipulator`: resizing, cropping, rotating, flipping and\n * re-encoding an image file.\n *\n * ```ts\n * import { ImageEditor, SaveFormat } from '@ng-native/expo/image-editor';\n *\n * private readonly editor = inject(ImageEditor);\n *\n * async thumbnail(uri: string): Promise<string | null> {\n *   const image = await this.editor.edit(uri, [{ resize: { width: 256 } }], {\n *     format: SaveFormat.WEBP,\n *     compress: 0.8,\n *   });\n *   return image?.uri ?? null;\n * }\n * ```\n *\n * `edit()` takes the module's own actions and save options - the shape of its `manipulateAsync`\n * - and runs them through the module's current contextual API: one context, each action applied\n * in order, the result rendered and saved to a new file in the cache. The context and the\n * rendered image are native memory nothing else holds, so both are released once the file is\n * written, including when it fails. `manipulate()` hands over the module's context itself, for a\n * caller that chains its own steps and releases it after.\n *\n * Without the module installed, `edit()` resolves to null and `manipulate()` is null.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport type {\n  Action,\n  FlipType as ExpoFlipType,\n  ImageManipulatorContext,\n  ImageResult,\n  SaveFormat as ExpoSaveFormat,\n  SaveOptions,\n} from 'expo-image-manipulator';\nimport { expoModule } from './native.ts';\n\ntype Expo = typeof import('expo-image-manipulator');\n\n/** The module's API this service calls. The real module is one; a test provides a fake. */\nexport type NativeImageEditor = Pick<Expo, 'ImageManipulator'>;\n\n/**\n * The formats an edited image is saved in, as `expo-image-manipulator`'s own enum. Importing the\n * enum from the module loads the module, which a test in Node cannot; these are the same strings,\n * typed as the enum.\n */\nexport const SaveFormat = {\n  JPEG: 'jpeg',\n  PNG: 'png',\n  WEBP: 'webp',\n} as unknown as typeof ExpoSaveFormat;\n\n/** The directions an image is flipped in, as the module's own enum. */\nexport const FlipType = {\n  Vertical: 'vertical',\n  Horizontal: 'horizontal',\n} as unknown as typeof ExpoFlipType;\n\n@Service()\nexport class ImageEditor {\n  /** Overridden in a test to edit images without decoding any. */\n  static readonly SOURCE = new InjectionToken<NativeImageEditor | null>(\n    'angular-native.imageEditorSource',\n    {\n      factory: () =>\n        expoModule('expo-image-manipulator', () => require('expo-image-manipulator') as Expo),\n    },\n  );\n\n  private readonly native = inject(ImageEditor.SOURCE);\n\n  /**\n   * Applies each action in order and saves the result as a new file: a JPEG unless `format` says\n   * otherwise, `compress` from 0 to 1, and `base64` to have the contents back as well. Each action\n   * has exactly one key: `resize`, `rotate` (degrees, clockwise), `flip`, `crop`, or on the web\n   * `extent`.\n   */\n  async edit(\n    source: string,\n    actions: readonly Action[] = [],\n    options: SaveOptions = {},\n  ): Promise<ImageResult | null> {\n    const context = this.manipulate(source);\n    if (!context) return null;\n    let image: Awaited<ReturnType<ImageManipulatorContext['renderAsync']>> | undefined;\n    try {\n      for (const action of actions) apply(context, action);\n      image = await context.renderAsync();\n      return await image.saveAsync({ format: SaveFormat.JPEG, ...options });\n    } finally {\n      context.release();\n      image?.release();\n    }\n  }\n\n  /**\n   * The module's own context for a file or data URI, for chaining steps by hand: `resize()`,\n   * `rotate()`, `flip()`, `crop()` and `reset()`, then `renderAsync()`. The caller\n   * releases it, and the image it renders, once done.\n   */\n  manipulate(source: string): ImageManipulatorContext | null {\n    return this.native?.ImageManipulator.manipulate(source) ?? null;\n  }\n}\n\nfunction apply(context: ImageManipulatorContext, action: Action): void {\n  if ('resize' in action) context.resize(action.resize);\n  else if ('rotate' in action) context.rotate(action.rotate);\n  else if ('flip' in action) context.flip(action.flip);\n  else if ('crop' in action) context.crop(action.crop);\n  // The web's context alone has `extent`; elsewhere the action is skipped, as the module skips it.\n  else if ('extent' in action) context.extent?.(action.extent);\n}\n"]}

package/dist/image-picker.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `ImagePicker`, bound to `expo-image-picker`.
+ *
+ * ```ts
+ * private readonly picker = inject(ImagePicker);
+ * const [photo] = await this.picker.pick({ mediaTypes: ['images'] });
+ * ```
+ *
+ * The options are Expo's own, passed through unchanged. What this adds is the two things every
+ * call site otherwise writes: a cancelled picker answers with no assets rather than a result to
+ * unwrap, and `capture()` asks for the camera before opening it, where Expo's would reject.
+ */
+import { InjectionToken } from '@angular/core';
+import { Permission, type PermissionResponse } from './permissions.ts';
+import * as i0 from "@angular/core";
+export type PickerOptions = import('expo-image-picker').ImagePickerOptions;
+export type PickedAsset = import('expo-image-picker').ImagePickerAsset;
+/** The slice of `expo-image-picker` this needs. */
+export interface NativeImagePicker {
+    launchImageLibraryAsync(options?: PickerOptions): Promise<PickerResult>;
+    launchCameraAsync(options?: PickerOptions): Promise<PickerResult>;
+    getMediaLibraryPermissionsAsync(): Promise<PermissionResponse>;
+    requestMediaLibraryPermissionsAsync(): Promise<PermissionResponse>;
+    getCameraPermissionsAsync(): Promise<PermissionResponse>;
+    requestCameraPermissionsAsync(): Promise<PermissionResponse>;
+}
+interface PickerResult {
+    readonly canceled: boolean;
+    readonly assets: readonly PickedAsset[] | null;
+}
+export declare class ImagePicker {
+    /** Overridden in a test to pick photos without a photo library. */
+    static readonly SOURCE: InjectionToken<NativeImagePicker | null>;
+    private readonly native;
+    /**
+     * The photo library. The system picker needs no permission to pick from, so `pick()` never
+     * asks; this is for an app that reads the library itself.
+     */
+    readonly libraryPermission: Permission;
+    /** The camera, which `capture()` asks for itself. */
+    readonly cameraPermission: Permission;
+    /** Pick from the photo library. Empty if they cancelled. */
+    pick(options?: PickerOptions): Promise<readonly PickedAsset[]>;
+    /** Take a photo or video with the system camera. Empty if they cancelled or refused it. */
+    capture(options?: PickerOptions): Promise<readonly PickedAsset[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImagePicker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};