@ng-native/expo 0.2.0 → 0.4.0

package/README.md

@@ -14,32 +14,18 @@ npm install @angular/core expo
 Every Expo module (`expo-haptics`, `expo-clipboard`, `expo-file-system`, and the rest) is an
 optional peer dependency: install only the ones the app actually uses.
 
-## Services
-
-One entry point per module, so importing haptics does not bundle the file system. Every source
-file lives in `src/`, as in every other package here; the entry points an app writes do not say so,
-because the `exports` map takes `@ng-native/expo/haptics` to `src/haptics.ts`. Most are
-`@Service()` classes that reach their native module through a static `SOURCE` token; `Fonts`,
-`SplashScreen`, `Storage`, `SecureStorage` and the sensors are `InjectionToken`s carrying their own
-factory. Either way there is nothing to provide and nothing to register - injecting it is the whole
-setup, and a service nobody injects is never constructed. Each token name is a type as well, so
-`inject(Storage)` and `private store: Storage` both work, as `inject(Clipboard)` does for a class.
+## Example
 
 ```ts
 import { Clipboard } from '@ng-native/expo/clipboard';
 import { FileSystem } from '@ng-native/expo/file-system';
-import { Fonts } from '@ng-native/expo/fonts';
 import { Haptics } from '@ng-native/expo/haptics';
-import { SplashScreen } from '@ng-native/expo/splash-screen';
 
 export class Notes {
   private readonly clipboard = inject(Clipboard);
   private readonly files = inject(FileSystem);
   private readonly haptics = inject(Haptics);
 
-  /** A signal: how many times the pasteboard has changed. */
-  protected readonly changes = this.clipboard.changes;
-
   protected async save(text: string): Promise<void> {
     this.files.write(this.files.document('notes.txt'), text);
     await this.clipboard.write(text);
@@ -48,370 +34,34 @@ export class Notes {
 }
 ```
 
-The names say what the thing is rather than who ships it, so app code asks for a clipboard rather
-than for a package. Two shapes are worth knowing about:
-
-- `Clipboard.changes` counts pasteboard changes; it does not hold the contents. On iOS 16 and
-  later, _reading_ the clipboard is what prompts the user for permission, so a signal that held
-  the text would prompt on every change - including changes made by other apps. The notification
-  is free and the read is explicit.
-- `Fonts` is the odd one out: the method that matters is called _before_ the injector exists.
-  See below.
-- `Haptics` returns nothing and swallows failures. Every Expo equivalent is a promise, and nobody
-  awaits a vibration; a device with no Taptic Engine would otherwise produce an unhandled
-  rejection for a feature that is by definition optional.
-
-## What this package costs to install
-
-One package. Every Expo module is an **optional peer dependency**, so `pnpm add
-@ng-native/expo` adds exactly itself - an app installs `expo-haptics` because it wants
-haptics, not because this asked for it. There is one entry point per module and each imports only
-its own, so reaching for haptics does not pull in the video player.
-
-The version ranges track the SDK rather than each package, because since SDK 57 Expo does too:
-`expo-battery` and `expo-video` are both `57.x` and ship together. That is also why this is one
-package and not twenty: twenty would have to be version-bumped in lockstep anyway, and would need
-a twenty-first to share `Permission`, `observed` and the rest.
-
-Each service is one file: a `@Service()` class that reaches its module through an injected source
-token. Nothing in the package statically imports an Expo module, because a file that does cannot be
-loaded by Node at all - Expo's build output uses extensionless relative imports, and what it pulls
-in reaches `react-native`, which is Flow. A `require` inside the token's factory has neither
-problem: Metro still resolves the string literal and bundles the module exactly as before, and in
-Node the call throws and the service goes inert. On a device, a module the app should have and does
-not - never installed, or installed without the app being rebuilt since - throws a
-`MissingModuleError` naming it and the commands that fix it.
-
-That token is also the test seam, and it hangs off the service rather than sitting beside it -
-`Clipboard.SOURCE`, not `CLIPBOARD_SOURCE`. One export per capability, and a token that cannot
-drift away from the thing it belongs to. A fake is _provided_ rather than passed, so a test drives
-the real service:
-
-```ts
-const clipboard = serviceWith(Clipboard.SOURCE, fake, () => new Clipboard());
-```
-
-Four are not services and say so: `Sensor` and `Store` are one class behind several tokens
-(`Accelerometer` and `Barometer` are the same class; so are `Storage` and `SecureStorage`), and
-`Fonts` and `SplashScreen` are called before an injector exists - `splashScreen.hold()` is the
-first thing an entry file does. Those four take their platform as a constructor argument.
-
-The app still installs `expo-haptics`, `expo-clipboard` and `expo-file-system` itself. That is
-what links the native side; whether we import their JavaScript is a separate question, and
-`Haptics` does not.
-
-## Fonts
-
-A font on a phone is not fetched when the text engine first needs it: it has to be registered
-with the platform before anything is laid out, or the first paint is in the fallback face and
-reflows when the real one lands. So a face is declared in CSS, collected at build time, and
-registered before the app mounts:
-
-```css
-@font-face {
-  font-family: Inter;
-  src: url('./fonts/Inter-Regular.ttf');
-}
-@font-face {
-  font-family: Inter;
-  src: url('./fonts/Inter-Bold.ttf');
-  font-weight: 700;
-}
-```
-
-```ts
-import { loadFonts } from '@ng-native/expo/fonts';
-
-await loadFonts(styleSheetOf(GlobalStyles));
-mount(rootTag, App, getFabricUIManager(), { globalStyles: styleSheetOf(GlobalStyles) });
-```
-
-`font-family: Inter` then means what it says. The `url()` becomes a `require` at build time, so
-the bundler ships the file - a plain path would be a font that is simply missing on the device
-with nothing anywhere to say why.
-
-**Weights and styles match as on the web.** Native looks a family up by name and that is all, so
-the second face above is registered as `Inter-700` as well, and the engine points a text with
-`font-family: Inter; font-weight: 700` at it, by CSS's matching rules, wherever the family and
-weight were set.
-
-`loadFonts` takes any number of sheets and does nothing at all when none of them declare a face,
-so bootstrap can call it unconditionally. Injecting `Fonts` afterwards answers what is loaded.
-
-## Device state
-
-Every module that reports something changing has the same three parts: a getter, a listener, and
-a `useX()` hook that is those two plus React state. The hook is the only surface some of them
-offer for reading a value _over time_, so it is what is rebuilt here - once, as a signal - and
-each module is a thin binding onto it.
-
-```ts
-private readonly network = inject(Network);
-private readonly battery = inject(Battery);
-
-protected readonly offline = computed(() => this.network.reachable() === false);
-protected readonly thrifty = computed(() => this.battery.saving() || this.battery.low());
-```
-
-- `Network.reachable()` is `null` until the platform establishes it, which is **not** the same as
-  offline: a captive-portal wifi is connected and reachable by nothing, and an offline banner that
-  treats `null` as false flashes on every cold start.
-- `Battery.low()` is under a fifth _and not charging_; plugged in at 15% is not a reason to do
-  less. Both signals start at their optimistic value, so an app never opens in its degraded mode.
-- `DeviceOrientation` is the device, not the window. A layout asking which way _it_ is laid out
-  wants the `orientation` media feature and needs none of this; a camera preview needs this,
-  because a screen pinned to portrait still has a phone that is sideways.
-- `Brightness.set()` and `DeviceOrientation.lock()` both return the function that undoes them,
-  ready for `DestroyRef.onDestroy`. An app that leaves the screen at full brightness after showing
-  a boarding pass is one the user experiences as a battery fault.
-
-### Sensors and locale
-
-The sensors are one class parameterized by the reading, not one per sensor - they are all the same
-object underneath. Nothing subscribes until `start`, and the interval is explicit:
-
-```ts
-inject(DestroyRef).onDestroy(inject(Accelerometer).start(50));
-```
-
-The sensible interval is a property of what the app is doing with it, a compass wants a tenth of a
-second and a shake detector less, and every event is a change-detection pass - so a sensor left at
-its default is a phone that never idles, and a sensor nobody stops is a battery nobody gets back.
-
-`Locale` is the odd one: both getters are synchronous, so there is no default to sit at. It is a
-service because the answers _change_ - a user can switch language in Settings and come back, and a
-date that was formatted correctly is then wrong. The list is ordered by preference and always has
-at least one entry, which is the reason to prefer it over a single locale string: an app that
-supports the user's second language should use it rather than fall back to English. `rtl()` is a
-layout decision rather than a translation one, which is why it is a signal.
-
-## Storage
-
-Both stores are already plain promises, so what is worth having is not a wrapper but a binding: a
-persisted value as a signal that writes through when set.
-
-```ts
-private readonly store = inject(Storage);
-protected readonly theme = this.store.signal<'light' | 'dark'>('theme', 'light');
-```
-
-Reading it is reading the preference; `theme.set('dark')` persists. The same key always hands back
-the same signal, so two components binding one preference stay in step, and a value written before
-the read comes back is not undone by it.
-
-`SecureStorage` is the keychain and the Android keystore - separate from `Storage` because the
-difference should be visible at the injection site. It can also answer synchronously, so a token
-never flashes its default.
-
-## Permissions
-
-Every Expo module that needs one spells it the same way - `getXPermissionsAsync`,
-`requestXPermissionsAsync`, and a `useXPermissions()` hook that is those two plus React state. So
-there is one class here rather than one facade per module, and the module stays the app's own
-dependency:
-
-```ts
-import { requestCameraPermissionsAsync, getCameraPermissionsAsync } from 'expo-camera';
-import { Permission } from '@ng-native/expo';
-
-readonly camera = Permission.of(getCameraPermissionsAsync, requestCameraPermissionsAsync);
-
-protected async open(): Promise<void> {
-  if (await this.camera.ensure()) this.scanning.set(true);
-}
-```
-
-`ensure()` is the method most call sites want: it checks first, so a permission the user granted
-months ago shows no dialog, and it does not ask when the platform has stopped asking - which
-would resolve to the same no while reading as though the user had been consulted. `blocked()` is
-how an app knows to offer Settings instead.
-
-`status()` distinguishes `unknown` from `undetermined`: nobody has asked the platform yet, versus
-the platform saying the user has not decided.
-
-## Splash screen
-
-The ordering is the whole feature, and it is easy to get subtly wrong. The native splash hides
-itself as soon as the first frame is drawn, so an app that loads fonts _before_ mounting shows a
-blank window for as long as that takes:
-
-```ts
-import { splashScreen } from '@ng-native/expo/splash-screen';
-import { loadFonts } from '@ng-native/expo/fonts';
-
-splashScreen.hold(); // module scope, before anything renders
-
-AppRegistry.registerRunnable('main', ({ rootTag }) => {
-  const fonts = loadFonts(styleSheetOf(GlobalStyles));
-  mount(Number(rootTag), App, getFabricUIManager(), { globalStyles: styleSheetOf(GlobalStyles) });
-  void splashScreen.hideWhenReady(fonts);
-});
-```
-
-Mounting does not wait for the fonts; the splash screen does. Text laid out before they arrive is
-laid out again as each face registers, behind the splash, so nothing is ever seen in the fallback
-face.
-`hideWhenReady` waits one frame after the work, because hiding the instant it resolves uncovers
-the frame that was on screen while it ran - and it uncovers even when the work fails, rather than
-leaving a splash screen up forever.
-
-## Media
-
-`useVideoPlayer` and `useAudioPlayer` are not where the player comes from - `createVideoPlayer`
-gives the same object. What the hooks add is the two things a component needs and cannot get
-otherwise: the player is _released_ when the component goes, and its changing state is _readable_,
-which its own mutable properties are not.
-
-```ts
-protected readonly player = videoPlayer(source, { timeUpdate: 0.5 });
-```
-
-```html
-<expo-video [player]="player.native" /> <text>{{ player.state().currentTime }}</text>
-```
-
-The player itself is passed straight through: it already has `play()`, `seekBy()` and the rest,
-and wrapping them would be a second place for each to be wrong. `timeUpdate` is off unless asked
-for, because it is the most frequent event either player emits and a screen with no progress bar
-should not pay for one.
-
-## Notifications
-
-Only the part React was holding. Scheduling, channels, categories, badges and tokens are already
-plain promises, and an app calls those on the module directly.
-
-What is here is the difference between a notification _arriving_ and a user _tapping_ one - the
-second is a navigation instruction - and the response that **launched** the app, which happened
-before any listener existed. Missing that is the single most common way notification routing is
-got wrong.
-
-```ts
-const tapped = inject(Notifications).take();
-if (tapped) this.router.navigateByUrl(routeFor(tapped));
-```
-
-`take()` rather than the signal, because routing on a tap is a one-off and a signal is not: an
-effect on one fires again whenever its component is recreated, sending the user back to a screen
-they had navigated away from. A second tap on the same notification is a new instruction and is
-handed over again.
-
-Pair it with `Permission.of(getPermissionsAsync, requestPermissionsAsync)` from the module.
-
-## Photos, files, location and privacy
-
-- **`ImagePicker`** (`image-picker.ts`): `pick()` and `capture()`, each resolving to the picked
-  assets, empty if they canceled. `capture()` asks for the camera itself.
-- **`Location`** (`location.ts`): a `position` signal, filled by `current(accuracy)` once or by
-  `start({ accuracy, distance })` until the function it returns is called.
-- **`Biometrics`** (`biometrics.ts`): `available()`, `kinds()` and `authenticate(message)`, which
-  fails rather than passes when the module is missing.
-- **`Browser`** (`browser.ts`): `open(url)`, and `signIn(url, redirectUrl)`, which resolves to the
-  URL the sign-in page redirected back to, or null.
-- **`AppInfo`** (`app-info.ts`): the version, build, identifier and device, as plain values.
-- **`Camera`** (`camera.ts`): a directive on `<expo-camera>` whose `takePicture()` takes a picture
-  from the view on screen, without a React ref.
-- **`StoreReview`** (`store-review.ts`): `available()`, `hasAction()`, `request()` and
-  `storeUrl()`. Whether the prompt appears is the platform's decision, and a call that resolves is
-  not a prompt that was shown.
-- **`Tracking`** (`tracking.ts`): App Tracking Transparency's `permission`, `available()` and
-  `advertisingId()`, which is null until tracking is allowed.
-- **`DocumentPicker`** (`document-picker.ts`): `pick(options)`, resolving to the files picked,
-  empty if they canceled.
-- **`Crypto`** (`crypto.ts`): `randomUUID()`, `digestString()`, `digest()`, `randomBytes()` and
-  `randomValues()`. The one service that throws without its module, since an empty identifier or
-  hash is a wrong answer that looks right.
-- **`BackgroundTask`** (`background-task.ts`): `status()`, `register(name, options)`,
-  `unregister(name)` and `triggerForTesting()`. The task itself is defined with
-  `expo-task-manager` at the top level of `main.ts`, since the platform runs it without
-  bootstrapping Angular.
-- **`ScreenCapture`** (`screen-capture.ts`): `prevent(key)` and `allow(key)`, which stay
-  prevented while any key is held, and a `screenshots` signal counting the screenshots taken.
-- **`ImageEditor`** (`image-editor.ts`): `edit(uri, actions, options)` over
-  `expo-image-manipulator`, resolving to the saved file and releasing the native context and
-  image it made, and `manipulate(uri)` for the module's own context.
-- **`MediaLibrary`** (`media-library.ts`): `save(uri, album)`, which asks for write-only access
-  itself, `assets(query)` and `metadata(query)` over the module's own `Query`, albums, the read
-  and write permissions, and `watch()` for changes, which starts listening only when called.
-
-## The rest
-
-Four more modules whose only entry point was a hook, each the same story: the work underneath is a
-plain promise, and what the hook adds is a _lifecycle_.
-
-- **`database(name, migrations)`** replaces `SQLiteProvider` and `useSQLiteContext`. Opened on
-  first use rather than at startup - a database opened eagerly is a file handle and a journal for
-  an app that may never read from it - and opened _once_ however many callers arrive while it is
-  opening, because two connections to one file is a lock waiting to happen. Migrations run in
-  order, each in a transaction, with the version recorded in SQLite's own `user_version`.
-- **`Updates`** checks and downloads in one call, because an app that checks without downloading
-  has learned something it cannot act on. `apply()` **restarts the app**, which is why nothing here
-  does it automatically: the moment is one the app knows and this does not. In Expo Go it reports
-  itself disabled rather than offering a banner that can never resolve.
-- **`assets(modules)`** preloads the images a screen should not pop in with, and resolves even when
-  one fails - a picture that will not appear is not a reason for the screen behind it to fail too.
-- **`KeepAwake.hold()`** returns the release, and is never a bare activate: a screen that holds the
-  display on and never lets go is a phone that never sleeps, which the user experiences as a
-  battery fault and never attributes to the app that caused it.
-
-## Views
-
-Most Expo modules need nothing from this package. `requireNativeModule`, `EventEmitter`,
-`SharedObject` and `SharedRef` have no React in them, so a module that only calls into native is
-imported and used as its own documentation says - the services above are a nicer surface, not a
-shim. Autolinking is unaffected too: it is driven by the `expo` package and the
-`expo-module.config.json` in each module, neither of which knows what renderer is above it.
-
-What does need something is a module that renders. `requireNativeViewManager` returns a React
-class, and the Fabric component underneath it is registered under a name derived from the module
-name and, in Expo Go, from a per-project identifier. `registerExpoView` derives the same name and
-hands it to the engine:
-
-```ts
-import {
-  registerExpoView,
-  registerExpoViews,
-  registerExpoUiViews,
-  registerNativeViews,
-} from '@ng-native/expo';
-
-registerExpoViews('expo-image', 'expo-blur'); // Expo's own
-registerNativeViews('web-view', 'slider'); // the community libraries in Expo's bundled list
-registerExpoUiViews(Platform.OS); // every @expo/ui control the platform has
-registerExpoView('my-module-view', 'MyModule'); // anything else
-```
-
-### @expo/ui
-
-The closest thing in the ecosystem to what this project is for: every one of these is a real
-platform control - a real `Picker`, a real `BottomSheet`, a real `Gauge` - rather than something
-drawn to look like one. `@expo/ui` reaches them through `requireNativeView('ExpoUI', ...)`, which
-is the derivation `registerExpoView` already mirrors, so the whole surface is a table of names.
-
-Element names are platform-neutral where both platforms have the control, so an app writes
-`<ui-slider>` once and `<ui-vstack>` gets Compose's `Column` on Android. Where only one platform
-has it - a `Gauge` is SwiftUI's, a `SearchBar` is Compose's - the element exists only there, since
-registering for the wrong platform is an element that commits as nothing.
-
-**A `<ui-host>` is required around any of them.** SwiftUI and Compose lay out their own subtrees,
-and the host view is what bridges Yoga's layout to theirs; without one the control has no size and
-does not appear - which looks exactly like a module that failed to install.
-
-`<expo-image>` is then an element like any other, and its props are the ones the module's native
-view declares - which is to say the ones the React component would have passed down, after
-whatever resolving it does in JavaScript:
-
-```html
-<expo-image [source]="[{ uri }]" contentFit="cover" [transition]="{ duration: 400 }" />
-```
-
-Most of that is deliberately not wrapped. An Angular component per Expo view, prop for prop, is
-a maintenance burden with no end; a name plus the module's own documentation covers the common
-case, and an app that wants a nicer surface can write the component it actually needs.
-
-The exception is strict templates, where an unknown element and every prop on it is a type error.
-The views apps reach for most (`ui-host`, `ui-menu`, `ui-button`, `ui-divider`, `ui-slot`,
-`ui-image`, `ui-text`, `ui-date-picker`) and `segmented-control` have thin typed components:
-import `UiHost`, `SegmentedControl` and the rest, and the element is typed while committing exactly
-as before. Keep registering the names too. The component supplies the types and the registration
-makes the element commit as the native view. Their events are outputs so `$event` is typed. The
-element's own event is what arrives, so bind them in a template.
+One entry point per module, so importing haptics does not bundle the file system. Nothing is
+provided anywhere - injecting a service is the whole setup, and a service nobody injects is never
+constructed. See [Using a module](https://ng-native.com/packages/expo/using-a-module) for how the
+`exports` map and the runtime fallback behind each service work.
+
+## What's in the package
+
+- Device state - `Battery`, `Brightness`, `Network`, `Orientation`, `Locale`, the sensors, `Fonts`,
+  `AppInfo`, `KeepAwake`.
+- Feedback - `Haptics`, `Clipboard`, `Notifications`, `StoreReview`.
+- Storage and files - `Storage`, `SecureStorage`, `FileSystem`, `database()`, `assets()`.
+- Media and camera - `ImagePicker`, `DocumentPicker`, `ImageEditor`, `MediaLibrary`, the `Camera`
+  directive, `videoPlayer()`/`audioPlayer()`.
+- Location and identity - `Location`, `Biometrics`, Sign in with Apple, `Tracking`, `Crypto`,
+  `ScreenCapture`, `Browser`.
+- App lifecycle - `splashScreen`, `Updates`, `BackgroundTask`.
+- Native views - `registerExpoView()`/`registerExpoViews()`, and the `@expo/ui` SwiftUI and
+  Jetpack Compose controls.
+- `Permission` - the `getXPermissionsAsync`/`requestXPermissionsAsync` pair any module exposes,
+  as one class.
+
+## Docs
+
+- [Expo](https://ng-native.com/packages/expo), with the full module list by category
+- [Using a module](https://ng-native.com/packages/expo/using-a-module) and
+  [permissions](https://ng-native.com/packages/expo/permissions)
+- [Root README](https://github.com/ng-native/ng-native/blob/main/README.md)
+
+## License
+
+MIT

package/dist/async-storage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `Storage`, a `Store` over `@react-native-async-storage/async-storage`: a plain key-value file.
+ *
+ * ```ts
+ * private readonly store = inject(Storage);
+ * protected readonly theme = this.store.signal<'light' | 'dark'>('theme', 'light');
+ * ```
+ *
+ * See `Store` in `@ng-native/expo/store` for what the signal does.
+ */
+import { InjectionToken } from '@angular/core';
+import { Store } from './store.ts';
+/** A plain key-value file. Bigger and faster than the keychain, and not private. */
+export declare const Storage: InjectionToken<Store>;
+export type Storage = Store;

package/dist/async-storage.js

@@ -0,0 +1,29 @@
+/**
+ * `Storage`, a `Store` over `@react-native-async-storage/async-storage`: a plain key-value file.
+ *
+ * ```ts
+ * private readonly store = inject(Storage);
+ * protected readonly theme = this.store.signal<'light' | 'dark'>('theme', 'light');
+ * ```
+ *
+ * See `Store` in `@ng-native/expo/store` for what the signal does.
+ */
+import { InjectionToken } from '@angular/core';
+import { expoModule } from "./native.js";
+import { Store } from "./store.js";
+const plain = () => {
+    const module = expoModule('@react-native-async-storage/async-storage', () => require('@react-native-async-storage/async-storage'));
+    const store = module?.default;
+    if (!store)
+        return null;
+    return {
+        get: (key) => store.getItem(key),
+        set: (key, value) => store.setItem(key, value),
+        remove: (key) => store.removeItem(key),
+    };
+};
+/** A plain key-value file. Bigger and faster than the keychain, and not private. */
+export const Storage = new InjectionToken('angular-native.storage', {
+    factory: () => new Store(plain()),
+});
+//# sourceMappingURL=async-storage.js.map

package/dist/async-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-storage.js","sourceRoot":"","sources":["../src/async-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,KAAK,EAAoB,MAAM,YAAY,CAAC;AAErD,MAAM,KAAK,GAAG,GAAuB,EAAE;IACrC,MAAM,MAAM,GAAG,UAAU,CACvB,2CAA2C,EAC3C,GAAG,EAAE,CACH,OAAO,CAAC,2CAA2C,CAElD,CACJ,CAAC;IACF,MAAM,KAAK,GAAG,MAAM,EAAE,OAAO,CAAC;IAC9B,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,OAAO;QACL,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QAChC,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC;QAC9C,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC;KACvC,CAAC;AACJ,CAAC,CAAC;AAEF,oFAAoF;AACpF,MAAM,CAAC,MAAM,OAAO,GAAG,IAAI,cAAc,CAAQ,wBAAwB,EAAE;IACzE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;CAClC,CAAC,CAAC","sourcesContent":["/**\n * `Storage`, a `Store` over `@react-native-async-storage/async-storage`: a plain key-value file.\n *\n * ```ts\n * private readonly store = inject(Storage);\n * protected readonly theme = this.store.signal<'light' | 'dark'>('theme', 'light');\n * ```\n *\n * See `Store` in `@ng-native/expo/store` for what the signal does.\n */\nimport { InjectionToken } from '@angular/core';\nimport { expoModule } from './native.ts';\nimport { Store, type NativeStore } from './store.ts';\n\nconst plain = (): NativeStore | null => {\n  const module = expoModule(\n    '@react-native-async-storage/async-storage',\n    () =>\n      require('@react-native-async-storage/async-storage') as {\n        default: typeof import('@react-native-async-storage/async-storage').default;\n      },\n  );\n  const store = module?.default;\n  if (!store) return null;\n  return {\n    get: (key) => store.getItem(key),\n    set: (key, value) => store.setItem(key, value),\n    remove: (key) => store.removeItem(key),\n  };\n};\n\n/** A plain key-value file. Bigger and faster than the keychain, and not private. */\nexport const Storage = new InjectionToken<Store>('angular-native.storage', {\n  factory: () => new Store(plain()),\n});\nexport type Storage = Store;\n"]}

package/dist/audio.d.ts

@@ -0,0 +1,10 @@
+import { type Player } from './player.ts';
+/**
+ * An audio player owned by the current component, released when it is destroyed.
+ *
+ * `expo-audio` has no `timeUpdateEventInterval` property to set after the fact - the interval is
+ * an option to `createAudioPlayer` itself, in milliseconds rather than `videoPlayer`'s seconds.
+ */
+export declare function audioPlayer(source: import('expo-audio').AudioSource, options?: {
+    timeUpdate?: number;
+}): Player<import('expo-audio').AudioPlayer>;

package/dist/audio.js

@@ -0,0 +1,26 @@
+/**
+ * `audioPlayer`, an `expo-audio` player owned by the component that makes it.
+ *
+ * ```ts
+ * protected readonly player = audioPlayer(this.source, { timeUpdate: 0.5 });
+ *
+ * // {{ player.state().currentTime }}
+ * ```
+ */
+import { expoModule, unavailable } from "./native.js";
+import { ownPlayer, watchAudioPlayer } from "./player.js";
+/**
+ * An audio player owned by the current component, released when it is destroyed.
+ *
+ * `expo-audio` has no `timeUpdateEventInterval` property to set after the fact - the interval is
+ * an option to `createAudioPlayer` itself, in milliseconds rather than `videoPlayer`'s seconds.
+ */
+export function audioPlayer(source, options = {}) {
+    const expo = expoModule('expo-audio', () => require('expo-audio'), ['ios', 'android', 'web']);
+    if (!expo)
+        throw unavailable('expo-audio', 'Stand in for the player in the test.');
+    const updateInterval = options.timeUpdate === undefined ? undefined : options.timeUpdate * 1000;
+    const native = expo.createAudioPlayer(source, { updateInterval });
+    return ownPlayer(native, () => watchAudioPlayer(native));
+}
+//# sourceMappingURL=audio.js.map

package/dist/audio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio.js","sourceRoot":"","sources":["../src/audio.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAe,MAAM,aAAa,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CACzB,MAAwC,EACxC,UAAmC,EAAE;IAErC,MAAM,IAAI,GAAG,UAAU,CACrB,YAAY,EACZ,GAAG,EAAE,CAAC,OAAO,CAAC,YAAY,CAAgC,EAC1D,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,CAC1B,CAAC;IACF,IAAI,CAAC,IAAI;QAAE,MAAM,WAAW,CAAC,YAAY,EAAE,sCAAsC,CAAC,CAAC;IACnF,MAAM,cAAc,GAAG,OAAO,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAChG,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC;IAClE,OAAO,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;AAC3D,CAAC","sourcesContent":["/**\n * `audioPlayer`, an `expo-audio` player owned by the component that makes it.\n *\n * ```ts\n * protected readonly player = audioPlayer(this.source, { timeUpdate: 0.5 });\n *\n * // {{ player.state().currentTime }}\n * ```\n */\nimport { expoModule, unavailable } from './native.ts';\nimport { ownPlayer, watchAudioPlayer, type Player } from './player.ts';\n\n/**\n * An audio player owned by the current component, released when it is destroyed.\n *\n * `expo-audio` has no `timeUpdateEventInterval` property to set after the fact - the interval is\n * an option to `createAudioPlayer` itself, in milliseconds rather than `videoPlayer`'s seconds.\n */\nexport function audioPlayer(\n  source: import('expo-audio').AudioSource,\n  options: { timeUpdate?: number } = {},\n): Player<import('expo-audio').AudioPlayer> {\n  const expo = expoModule(\n    'expo-audio',\n    () => require('expo-audio') as typeof import('expo-audio'),\n    ['ios', 'android', 'web'],\n  );\n  if (!expo) throw unavailable('expo-audio', 'Stand in for the player in the test.');\n  const updateInterval = options.timeUpdate === undefined ? undefined : options.timeUpdate * 1000;\n  const native = expo.createAudioPlayer(source, { updateInterval });\n  return ownPlayer(native, () => watchAudioPlayer(native));\n}\n"]}

package/dist/community-views.js

@@ -22,7 +22,7 @@ export const NATIVE_VIEWS = {
     'web-view': ['RNCWebView', { javaScriptEnabled: true, domStorageEnabled: true }],
     /** `@react-native-community/slider`. */
     slider: ['RNCSlider', { maximumValue: 1, minimumValue: 0, step: 0 }],
-    /** `@react-native-community/datetimepicker`. Android renders a dialog, iOS an inline view. */
+    /** `@react-native-community/datetimepicker`. iOS only: on Android the library has no view. */
     'date-time-picker': ['RNDateTimePicker'],
     /** `@react-native-picker/picker`, whose items are `<picker-item>` children. */
     picker: ['RNCPicker'],

package/dist/community-views.js.map

@@ -1 +1 @@
-{"version":3,"file":"community-views.js","sourceRoot":"","sources":["../src/community-views.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,gGAAgG;AAChG,MAAM,CAAC,MAAM,YAAY,GAAiE;IACxF,8BAA8B;IAC9B,UAAU,EAAE,CAAC,YAAY,EAAE,EAAE,iBAAiB,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAAC;IAChF,wCAAwC;IACxC,MAAM,EAAE,CAAC,WAAW,EAAE,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;IACpE,8FAA8F;IAC9F,kBAAkB,EAAE,CAAC,kBAAkB,CAAC;IACxC,+EAA+E;IAC/E,MAAM,EAAE,CAAC,WAAW,CAAC;IACrB,aAAa,EAAE,CAAC,eAAe,CAAC;IAChC;;;;;;OAMG;IACH,mBAAmB,EAAE,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAChE,yFAAyF;IACzF,aAAa,EAAE,CAAC,eAAe,CAAC;IAChC,+EAA+E;IAC/E,YAAY,EAAE,CAAC,cAAc,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;IAClD,6BAA6B;IAC7B,aAAa,EAAE,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACtE;;;;;;;;OAQG;IACH,WAAW,EAAE,CAAC,iBAAiB,CAAC;IAChC,kEAAkE;IAClE,WAAW,EAAE,CAAC,aAAa,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAG,QAAgD;IACrF,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,OAAO,GAAG,CAAC,CAAC;QACxF,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;AACH,CAAC","sourcesContent":["/**\n * Native views from the libraries an Expo app already reaches for, by element name.\n *\n * These are not Expo modules, so their Fabric names are their own - what codegen produced from\n * each library's spec - rather than the `ViewManagerAdapter_` names `registerExpoView` derives.\n * They are here because they are in Expo's own bundled module list, which is the list an app\n * actually installs from, and because the alternative is every app looking each name up in a\n * library's generated code.\n *\n * Names and defaults, not components. An Angular component per native view, prop for prop, is a\n * maintenance burden with no end and a second place for every prop to be wrong. An app writes the\n * small component for the one it uses - a selector, and an input per prop it binds, passed through\n * as a host binding - which keeps its template checked; see `ExpoImage` for the shape.\n *\n * A library still has to be installed for its element to commit as anything. This is the\n * JavaScript half; an element whose native side is missing commits as `UnimplementedNativeView`.\n */\nimport { registerViewName } from '@ng-native/fabric';\n\n/** Element name -> the Fabric component name, and the props its React wrapper would default. */\nexport const NATIVE_VIEWS: Readonly<Record<string, [string, Record<string, unknown>?]>> = {\n  /** `react-native-webview`. */\n  'web-view': ['RNCWebView', { javaScriptEnabled: true, domStorageEnabled: true }],\n  /** `@react-native-community/slider`. */\n  slider: ['RNCSlider', { maximumValue: 1, minimumValue: 0, step: 0 }],\n  /** `@react-native-community/datetimepicker`. Android renders a dialog, iOS an inline view. */\n  'date-time-picker': ['RNDateTimePicker'],\n  /** `@react-native-picker/picker`, whose items are `<picker-item>` children. */\n  picker: ['RNCPicker'],\n  'picker-item': ['RNCPickerItem'],\n  /**\n   * `@react-native-segmented-control/segmented-control`. iOS only.\n   *\n   * A view manager from before Fabric, run through the interop layer, which only installs the\n   * `onChange` block when the prop is set - as React's handler does by being there. Without it\n   * the control changes on screen and nothing hears about it.\n   */\n  'segmented-control': ['RNCSegmentedControl', { onChange: true }],\n  /** `@react-native-masked-view/masked-view`: its `maskElement` is a prop, not a child. */\n  'masked-view': ['RNCMaskedView'],\n  /** `react-native-pager-view`, the swipeable pager a tab layout is built on. */\n  'pager-view': ['RNCViewPager', { initialPage: 0 }],\n  /** `lottie-react-native`. */\n  'lottie-view': ['LottieAnimationView', { autoPlay: true, loop: true }],\n  /**\n   * `@shopify/react-native-skia`.\n   *\n   * The view is real and this name is right, but it is worth being plain: Skia's drawing model is\n   * React elements through a reconciler of its own - `<Canvas><Path/></Canvas>` - and none of that\n   * is reachable here. What a `<skia-view>` will take is a `picture`, built with Skia's imperative\n   * `PictureRecorder` API, which has no React in it. Anything drawn declaratively does not come\n   * across, and a component that renders nothing is what that looks like.\n   */\n  'skia-view': ['SkiaPictureView'],\n  /** `react-native-view-shot`, which captures whatever it wraps. */\n  'view-shot': ['RNCViewShot'],\n};\n\n/**\n * Register several of the known views by element name.\n *\n * ```ts\n * registerNativeViews('web-view', 'slider');\n * ```\n *\n * Named one at a time rather than all at once on purpose: registering a view for a library the\n * app has not installed produces an element that commits as nothing, and finding out at startup\n * which libraries are present is not something JavaScript can do without importing them all.\n */\nexport function registerNativeViews(...elements: readonly (keyof typeof NATIVE_VIEWS)[]): void {\n  for (const element of elements) {\n    const known = NATIVE_VIEWS[element];\n    if (!known) throw new Error(`[angular-native] no native view is known as '${element}'`);\n    registerViewName(element, known[0], known[1]);\n  }\n}\n"]}
+{"version":3,"file":"community-views.js","sourceRoot":"","sources":["../src/community-views.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,gGAAgG;AAChG,MAAM,CAAC,MAAM,YAAY,GAAiE;IACxF,8BAA8B;IAC9B,UAAU,EAAE,CAAC,YAAY,EAAE,EAAE,iBAAiB,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAAC;IAChF,wCAAwC;IACxC,MAAM,EAAE,CAAC,WAAW,EAAE,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;IACpE,8FAA8F;IAC9F,kBAAkB,EAAE,CAAC,kBAAkB,CAAC;IACxC,+EAA+E;IAC/E,MAAM,EAAE,CAAC,WAAW,CAAC;IACrB,aAAa,EAAE,CAAC,eAAe,CAAC;IAChC;;;;;;OAMG;IACH,mBAAmB,EAAE,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAChE,yFAAyF;IACzF,aAAa,EAAE,CAAC,eAAe,CAAC;IAChC,+EAA+E;IAC/E,YAAY,EAAE,CAAC,cAAc,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;IAClD,6BAA6B;IAC7B,aAAa,EAAE,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACtE;;;;;;;;OAQG;IACH,WAAW,EAAE,CAAC,iBAAiB,CAAC;IAChC,kEAAkE;IAClE,WAAW,EAAE,CAAC,aAAa,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAG,QAAgD;IACrF,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,OAAO,GAAG,CAAC,CAAC;QACxF,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;AACH,CAAC","sourcesContent":["/**\n * Native views from the libraries an Expo app already reaches for, by element name.\n *\n * These are not Expo modules, so their Fabric names are their own - what codegen produced from\n * each library's spec - rather than the `ViewManagerAdapter_` names `registerExpoView` derives.\n * They are here because they are in Expo's own bundled module list, which is the list an app\n * actually installs from, and because the alternative is every app looking each name up in a\n * library's generated code.\n *\n * Names and defaults, not components. An Angular component per native view, prop for prop, is a\n * maintenance burden with no end and a second place for every prop to be wrong. An app writes the\n * small component for the one it uses - a selector, and an input per prop it binds, passed through\n * as a host binding - which keeps its template checked; see `ExpoImage` for the shape.\n *\n * A library still has to be installed for its element to commit as anything. This is the\n * JavaScript half; an element whose native side is missing commits as `UnimplementedNativeView`.\n */\nimport { registerViewName } from '@ng-native/fabric';\n\n/** Element name -> the Fabric component name, and the props its React wrapper would default. */\nexport const NATIVE_VIEWS: Readonly<Record<string, [string, Record<string, unknown>?]>> = {\n  /** `react-native-webview`. */\n  'web-view': ['RNCWebView', { javaScriptEnabled: true, domStorageEnabled: true }],\n  /** `@react-native-community/slider`. */\n  slider: ['RNCSlider', { maximumValue: 1, minimumValue: 0, step: 0 }],\n  /** `@react-native-community/datetimepicker`. iOS only: on Android the library has no view. */\n  'date-time-picker': ['RNDateTimePicker'],\n  /** `@react-native-picker/picker`, whose items are `<picker-item>` children. */\n  picker: ['RNCPicker'],\n  'picker-item': ['RNCPickerItem'],\n  /**\n   * `@react-native-segmented-control/segmented-control`. iOS only.\n   *\n   * A view manager from before Fabric, run through the interop layer, which only installs the\n   * `onChange` block when the prop is set - as React's handler does by being there. Without it\n   * the control changes on screen and nothing hears about it.\n   */\n  'segmented-control': ['RNCSegmentedControl', { onChange: true }],\n  /** `@react-native-masked-view/masked-view`: its `maskElement` is a prop, not a child. */\n  'masked-view': ['RNCMaskedView'],\n  /** `react-native-pager-view`, the swipeable pager a tab layout is built on. */\n  'pager-view': ['RNCViewPager', { initialPage: 0 }],\n  /** `lottie-react-native`. */\n  'lottie-view': ['LottieAnimationView', { autoPlay: true, loop: true }],\n  /**\n   * `@shopify/react-native-skia`.\n   *\n   * The view is real and this name is right, but it is worth being plain: Skia's drawing model is\n   * React elements through a reconciler of its own - `<Canvas><Path/></Canvas>` - and none of that\n   * is reachable here. What a `<skia-view>` will take is a `picture`, built with Skia's imperative\n   * `PictureRecorder` API, which has no React in it. Anything drawn declaratively does not come\n   * across, and a component that renders nothing is what that looks like.\n   */\n  'skia-view': ['SkiaPictureView'],\n  /** `react-native-view-shot`, which captures whatever it wraps. */\n  'view-shot': ['RNCViewShot'],\n};\n\n/**\n * Register several of the known views by element name.\n *\n * ```ts\n * registerNativeViews('web-view', 'slider');\n * ```\n *\n * Named one at a time rather than all at once on purpose: registering a view for a library the\n * app has not installed produces an element that commits as nothing, and finding out at startup\n * which libraries are present is not something JavaScript can do without importing them all.\n */\nexport function registerNativeViews(...elements: readonly (keyof typeof NATIVE_VIEWS)[]): void {\n  for (const element of elements) {\n    const known = NATIVE_VIEWS[element];\n    if (!known) throw new Error(`[angular-native] no native view is known as '${element}'`);\n    registerViewName(element, known[0], known[1]);\n  }\n}\n"]}

package/dist/crypto.js

@@ -20,7 +20,7 @@
  * the data is. So every call without the module throws, naming the package to install.
  */
 import { InjectionToken, Service, inject } from '@angular/core';
-import { expoModule } from "./native.js";
+import { expoModule, unavailable } from "./native.js";
 import * as i0 from "@angular/core";
 /**
  * The hash algorithms, as `expo-crypto`'s own enum. Importing the enum from the module loads the
@@ -72,7 +72,7 @@ export class Crypto {
     }
     module() {
         if (!this.native)
-            throw new Error('Crypto needs expo-crypto: npx expo install expo-crypto');
+            throw unavailable('expo-crypto', 'Provide Crypto.SOURCE with a stand-in.');
         return this.native;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Crypto, deps: [], target: i0.ɵɵFactoryTarget.Service });

package/dist/crypto.js.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAKhE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;;AAiBzC;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,IAAI,EAAE,OAAO;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,SAAS;IACjB,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;CAC8B,CAAC;AAE3C,mGAAmG;AACnG,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;CACiB,CAAC;AAGpC,MAAM,OAAO,MAAM;IACjB,wEAAwE;IACxE,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CAAsB,6BAA6B,EAAE;QAC9F,OAAO,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,aAAa,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,aAAa,CAAS,CAAC;KAC/E,CAAC,CAAC;IAEc,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAEhD,kEAAkE;IAClE,UAAU;QACR,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,UAAU,EAAE,CAAC;IACpC,CAAC;IAED,8CAA8C;IAC9C,KAAK,CAAC,YAAY,CAAC,GAAG,IAA+B;QACnD,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,8DAA8D;IAC9D,KAAK,CAAC,MAAM,CAAC,GAAG,IAAoB;QAClC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IACvC,CAAC;IAED,yEAAyE;IACzE,WAAW,CAAC,KAAa;QACvB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED,8BAA8B;IAC9B,KAAK,CAAC,gBAAgB,CAAC,KAAa;QAClC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IAED,iGAAiG;IACjG,YAAY,CAAuC,KAAQ;QACzD,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAEO,MAAM;QACZ,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5F,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;uGAzCU,MAAM;wGAAN,MAAM;;2FAAN,MAAM;kBADlB,OAAO","sourcesContent":["/**\n * `Crypto`, bound to `expo-crypto`: random identifiers, random bytes, and hashes.\n *\n * ```ts\n * import { Crypto, CryptoDigestAlgorithm } from '@ng-native/expo/crypto';\n *\n * private readonly crypto = inject(Crypto);\n *\n * readonly id = this.crypto.randomUUID();\n * async fingerprint(text: string): Promise<string> {\n *   return this.crypto.digestString(CryptoDigestAlgorithm.SHA256, text);\n * }\n * ```\n *\n * The module's functions under shorter names, with its own types. Hermes has no Web Crypto, so\n * this is where a UUID or a hash comes from on a device.\n *\n * Unlike the other Expo services, this one is not inert without its module. An empty identifier\n * is a key every record shares, and an empty hash matches every input; neither looks wrong until\n * the data is. So every call without the module throws, naming the package to install.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport type {\n  CryptoDigestAlgorithm as ExpoDigestAlgorithm,\n  CryptoEncoding as ExpoEncoding,\n} from 'expo-crypto';\nimport { expoModule } from './native.ts';\n\ntype Expo = typeof import('expo-crypto');\n\n/** The module's functions this service calls. The real module is one; a test provides a fake. */\nexport type NativeCrypto = Pick<\n  Expo,\n  | 'randomUUID'\n  | 'digestStringAsync'\n  | 'digest'\n  | 'getRandomBytes'\n  | 'getRandomBytesAsync'\n  | 'getRandomValues'\n>;\n\ntype Args<K extends keyof NativeCrypto> = Parameters<NativeCrypto[K]>;\n\n/**\n * The hash algorithms, as `expo-crypto`'s own enum. Importing the enum from the module loads the\n * module, which a test in Node cannot; these are the same strings, typed as the enum.\n */\nexport const CryptoDigestAlgorithm = {\n  SHA1: 'SHA-1',\n  SHA256: 'SHA-256',\n  SHA384: 'SHA-384',\n  SHA512: 'SHA-512',\n  MD2: 'MD2',\n  MD4: 'MD4',\n  MD5: 'MD5',\n} as unknown as typeof ExpoDigestAlgorithm;\n\n/** How `digestString` writes its hash, as `expo-crypto`'s own enum: hex unless asked otherwise. */\nexport const CryptoEncoding = {\n  HEX: 'hex',\n  BASE64: 'base64',\n} as unknown as typeof ExpoEncoding;\n\n@Service()\nexport class Crypto {\n  /** Overridden in a test to hand out identifiers that are not random. */\n  static readonly SOURCE = new InjectionToken<NativeCrypto | null>('angular-native.cryptoSource', {\n    factory: () => expoModule('expo-crypto', () => require('expo-crypto') as Expo),\n  });\n\n  private readonly native = inject(Crypto.SOURCE);\n\n  /** A version 4 UUID, from the platform's secure random source. */\n  randomUUID(): string {\n    return this.module().randomUUID();\n  }\n\n  /** The hash of a string, as hex or base64. */\n  async digestString(...args: Args<'digestStringAsync'>): Promise<string> {\n    return this.module().digestStringAsync(...args);\n  }\n\n  /** The hash of bytes, as Web Crypto's `digest` answers it. */\n  async digest(...args: Args<'digest'>): Promise<ArrayBuffer> {\n    return this.module().digest(...args);\n  }\n\n  /** Cryptographically secure random bytes, between 0 and 1024 of them. */\n  randomBytes(count: number): Uint8Array {\n    return this.module().getRandomBytes(count);\n  }\n\n  /** The same, as a promise. */\n  async randomBytesAsync(count: number): Promise<Uint8Array> {\n    return this.module().getRandomBytesAsync(count);\n  }\n\n  /** Fills an integer typed array with secure random values and hands it back, as Web Crypto's. */\n  randomValues<T extends Args<'getRandomValues'>[0]>(array: T): T {\n    return this.module().getRandomValues(array);\n  }\n\n  private module(): NativeCrypto {\n    if (!this.native) throw new Error('Crypto needs expo-crypto: npx expo install expo-crypto');\n    return this.native;\n  }\n}\n"]}
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAKhE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;;AAiBtD;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,IAAI,EAAE,OAAO;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,SAAS;IACjB,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;CAC8B,CAAC;AAE3C,mGAAmG;AACnG,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;CACiB,CAAC;AAGpC,MAAM,OAAO,MAAM;IACjB,wEAAwE;IACxE,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CAAsB,6BAA6B,EAAE;QAC9F,OAAO,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,aAAa,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,aAAa,CAAS,CAAC;KAC/E,CAAC,CAAC;IAEc,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAEhD,kEAAkE;IAClE,UAAU;QACR,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,UAAU,EAAE,CAAC;IACpC,CAAC;IAED,8CAA8C;IAC9C,KAAK,CAAC,YAAY,CAAC,GAAG,IAA+B;QACnD,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,8DAA8D;IAC9D,KAAK,CAAC,MAAM,CAAC,GAAG,IAAoB;QAClC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IACvC,CAAC;IAED,yEAAyE;IACzE,WAAW,CAAC,KAAa;QACvB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED,8BAA8B;IAC9B,KAAK,CAAC,gBAAgB,CAAC,KAAa;QAClC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IAED,iGAAiG;IACjG,YAAY,CAAuC,KAAQ;QACzD,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAEO,MAAM;QACZ,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,MAAM,WAAW,CAAC,aAAa,EAAE,wCAAwC,CAAC,CAAC;QAC7F,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;uGAzCU,MAAM;wGAAN,MAAM;;2FAAN,MAAM;kBADlB,OAAO","sourcesContent":["/**\n * `Crypto`, bound to `expo-crypto`: random identifiers, random bytes, and hashes.\n *\n * ```ts\n * import { Crypto, CryptoDigestAlgorithm } from '@ng-native/expo/crypto';\n *\n * private readonly crypto = inject(Crypto);\n *\n * readonly id = this.crypto.randomUUID();\n * async fingerprint(text: string): Promise<string> {\n *   return this.crypto.digestString(CryptoDigestAlgorithm.SHA256, text);\n * }\n * ```\n *\n * The module's functions under shorter names, with its own types. Hermes has no Web Crypto, so\n * this is where a UUID or a hash comes from on a device.\n *\n * Unlike the other Expo services, this one is not inert without its module. An empty identifier\n * is a key every record shares, and an empty hash matches every input; neither looks wrong until\n * the data is. So every call without the module throws, naming the package to install.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport type {\n  CryptoDigestAlgorithm as ExpoDigestAlgorithm,\n  CryptoEncoding as ExpoEncoding,\n} from 'expo-crypto';\nimport { expoModule, unavailable } from './native.ts';\n\ntype Expo = typeof import('expo-crypto');\n\n/** The module's functions this service calls. The real module is one; a test provides a fake. */\nexport type NativeCrypto = Pick<\n  Expo,\n  | 'randomUUID'\n  | 'digestStringAsync'\n  | 'digest'\n  | 'getRandomBytes'\n  | 'getRandomBytesAsync'\n  | 'getRandomValues'\n>;\n\ntype Args<K extends keyof NativeCrypto> = Parameters<NativeCrypto[K]>;\n\n/**\n * The hash algorithms, as `expo-crypto`'s own enum. Importing the enum from the module loads the\n * module, which a test in Node cannot; these are the same strings, typed as the enum.\n */\nexport const CryptoDigestAlgorithm = {\n  SHA1: 'SHA-1',\n  SHA256: 'SHA-256',\n  SHA384: 'SHA-384',\n  SHA512: 'SHA-512',\n  MD2: 'MD2',\n  MD4: 'MD4',\n  MD5: 'MD5',\n} as unknown as typeof ExpoDigestAlgorithm;\n\n/** How `digestString` writes its hash, as `expo-crypto`'s own enum: hex unless asked otherwise. */\nexport const CryptoEncoding = {\n  HEX: 'hex',\n  BASE64: 'base64',\n} as unknown as typeof ExpoEncoding;\n\n@Service()\nexport class Crypto {\n  /** Overridden in a test to hand out identifiers that are not random. */\n  static readonly SOURCE = new InjectionToken<NativeCrypto | null>('angular-native.cryptoSource', {\n    factory: () => expoModule('expo-crypto', () => require('expo-crypto') as Expo),\n  });\n\n  private readonly native = inject(Crypto.SOURCE);\n\n  /** A version 4 UUID, from the platform's secure random source. */\n  randomUUID(): string {\n    return this.module().randomUUID();\n  }\n\n  /** The hash of a string, as hex or base64. */\n  async digestString(...args: Args<'digestStringAsync'>): Promise<string> {\n    return this.module().digestStringAsync(...args);\n  }\n\n  /** The hash of bytes, as Web Crypto's `digest` answers it. */\n  async digest(...args: Args<'digest'>): Promise<ArrayBuffer> {\n    return this.module().digest(...args);\n  }\n\n  /** Cryptographically secure random bytes, between 0 and 1024 of them. */\n  randomBytes(count: number): Uint8Array {\n    return this.module().getRandomBytes(count);\n  }\n\n  /** The same, as a promise. */\n  async randomBytesAsync(count: number): Promise<Uint8Array> {\n    return this.module().getRandomBytesAsync(count);\n  }\n\n  /** Fills an integer typed array with secure random values and hands it back, as Web Crypto's. */\n  randomValues<T extends Args<'getRandomValues'>[0]>(array: T): T {\n    return this.module().getRandomValues(array);\n  }\n\n  private module(): NativeCrypto {\n    if (!this.native) throw unavailable('expo-crypto', 'Provide Crypto.SOURCE with a stand-in.');\n    return this.native;\n  }\n}\n"]}