@ng-native/expo 0.0.1 → 0.1.1

package/dist/community-views.js

@@ -0,0 +1,76 @@
+/**
+ * Native views from the libraries an Expo app already reaches for, by element name.
+ *
+ * These are not Expo modules, so their Fabric names are their own - what codegen produced from
+ * each library's spec - rather than the `ViewManagerAdapter_` names `registerExpoView` derives.
+ * They are here because they are in Expo's own bundled module list, which is the list an app
+ * actually installs from, and because the alternative is every app looking each name up in a
+ * library's generated code.
+ *
+ * Names and defaults, not components. An Angular component per native view, prop for prop, is a
+ * maintenance burden with no end and a second place for every prop to be wrong. An app writes the
+ * small component for the one it uses - a selector, and an input per prop it binds, passed through
+ * as a host binding - which keeps its template checked; see `ExpoImage` for the shape.
+ *
+ * A library still has to be installed for its element to commit as anything. This is the
+ * JavaScript half; an element whose native side is missing commits as `UnimplementedNativeView`.
+ */
+import { registerViewName } from '@ng-native/fabric';
+/** Element name -> the Fabric component name, and the props its React wrapper would default. */
+export const NATIVE_VIEWS = {
+    /** `react-native-webview`. */
+    '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. */
+    'date-time-picker': ['RNDateTimePicker'],
+    /** `@react-native-picker/picker`, whose items are `<picker-item>` children. */
+    picker: ['RNCPicker'],
+    'picker-item': ['RNCPickerItem'],
+    /**
+     * `@react-native-segmented-control/segmented-control`. iOS only.
+     *
+     * A view manager from before Fabric, run through the interop layer, which only installs the
+     * `onChange` block when the prop is set - as React's handler does by being there. Without it
+     * the control changes on screen and nothing hears about it.
+     */
+    'segmented-control': ['RNCSegmentedControl', { onChange: true }],
+    /** `@react-native-masked-view/masked-view`: its `maskElement` is a prop, not a child. */
+    'masked-view': ['RNCMaskedView'],
+    /** `react-native-pager-view`, the swipeable pager a tab layout is built on. */
+    'pager-view': ['RNCViewPager', { initialPage: 0 }],
+    /** `lottie-react-native`. */
+    'lottie-view': ['LottieAnimationView', { autoPlay: true, loop: true }],
+    /**
+     * `@shopify/react-native-skia`.
+     *
+     * The view is real and this name is right, but it is worth being plain: Skia's drawing model is
+     * React elements through a reconciler of its own - `<Canvas><Path/></Canvas>` - and none of that
+     * is reachable here. What a `<skia-view>` will take is a `picture`, built with Skia's imperative
+     * `PictureRecorder` API, which has no React in it. Anything drawn declaratively does not come
+     * across, and a component that renders nothing is what that looks like.
+     */
+    'skia-view': ['SkiaPictureView'],
+    /** `react-native-view-shot`, which captures whatever it wraps. */
+    'view-shot': ['RNCViewShot'],
+};
+/**
+ * Register several of the known views by element name.
+ *
+ * ```ts
+ * registerNativeViews('web-view', 'slider');
+ * ```
+ *
+ * Named one at a time rather than all at once on purpose: registering a view for a library the
+ * app has not installed produces an element that commits as nothing, and finding out at startup
+ * which libraries are present is not something JavaScript can do without importing them all.
+ */
+export function registerNativeViews(...elements) {
+    for (const element of elements) {
+        const known = NATIVE_VIEWS[element];
+        if (!known)
+            throw new Error(`[angular-native] no native view is known as '${element}'`);
+        registerViewName(element, known[0], known[1]);
+    }
+}
+//# sourceMappingURL=community-views.js.map

package/dist/community-views.js.map

@@ -0,0 +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"]}

package/dist/crypto.d.ts

@@ -0,0 +1,56 @@
+/**
+ * `Crypto`, bound to `expo-crypto`: random identifiers, random bytes, and hashes.
+ *
+ * ```ts
+ * import { Crypto, CryptoDigestAlgorithm } from '@ng-native/expo/crypto';
+ *
+ * private readonly crypto = inject(Crypto);
+ *
+ * readonly id = this.crypto.randomUUID();
+ * async fingerprint(text: string): Promise<string> {
+ *   return this.crypto.digestString(CryptoDigestAlgorithm.SHA256, text);
+ * }
+ * ```
+ *
+ * The module's functions under shorter names, with its own types. Hermes has no Web Crypto, so
+ * this is where a UUID or a hash comes from on a device.
+ *
+ * Unlike the other Expo services, this one is not inert without its module. An empty identifier
+ * is a key every record shares, and an empty hash matches every input; neither looks wrong until
+ * the data is. So every call without the module throws, naming the package to install.
+ */
+import { InjectionToken } from '@angular/core';
+import type { CryptoDigestAlgorithm as ExpoDigestAlgorithm, CryptoEncoding as ExpoEncoding } from 'expo-crypto';
+import * as i0 from "@angular/core";
+type Expo = typeof import('expo-crypto');
+/** The module's functions this service calls. The real module is one; a test provides a fake. */
+export type NativeCrypto = Pick<Expo, 'randomUUID' | 'digestStringAsync' | 'digest' | 'getRandomBytes' | 'getRandomBytesAsync' | 'getRandomValues'>;
+type Args<K extends keyof NativeCrypto> = Parameters<NativeCrypto[K]>;
+/**
+ * The hash algorithms, as `expo-crypto`'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 CryptoDigestAlgorithm: typeof ExpoDigestAlgorithm;
+/** How `digestString` writes its hash, as `expo-crypto`'s own enum: hex unless asked otherwise. */
+export declare const CryptoEncoding: typeof ExpoEncoding;
+export declare class Crypto {
+    /** Overridden in a test to hand out identifiers that are not random. */
+    static readonly SOURCE: InjectionToken<NativeCrypto | null>;
+    private readonly native;
+    /** A version 4 UUID, from the platform's secure random source. */
+    randomUUID(): string;
+    /** The hash of a string, as hex or base64. */
+    digestString(...args: Args<'digestStringAsync'>): Promise<string>;
+    /** The hash of bytes, as Web Crypto's `digest` answers it. */
+    digest(...args: Args<'digest'>): Promise<ArrayBuffer>;
+    /** Cryptographically secure random bytes, between 0 and 1024 of them. */
+    randomBytes(count: number): Uint8Array;
+    /** The same, as a promise. */
+    randomBytesAsync(count: number): Promise<Uint8Array>;
+    /** Fills an integer typed array with secure random values and hands it back, as Web Crypto's. */
+    randomValues<T extends Args<'getRandomValues'>[0]>(array: T): T;
+    private module;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Crypto, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};

package/dist/crypto.js

@@ -0,0 +1,84 @@
+/**
+ * `Crypto`, bound to `expo-crypto`: random identifiers, random bytes, and hashes.
+ *
+ * ```ts
+ * import { Crypto, CryptoDigestAlgorithm } from '@ng-native/expo/crypto';
+ *
+ * private readonly crypto = inject(Crypto);
+ *
+ * readonly id = this.crypto.randomUUID();
+ * async fingerprint(text: string): Promise<string> {
+ *   return this.crypto.digestString(CryptoDigestAlgorithm.SHA256, text);
+ * }
+ * ```
+ *
+ * The module's functions under shorter names, with its own types. Hermes has no Web Crypto, so
+ * this is where a UUID or a hash comes from on a device.
+ *
+ * Unlike the other Expo services, this one is not inert without its module. An empty identifier
+ * is a key every record shares, and an empty hash matches every input; neither looks wrong until
+ * 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 * as i0 from "@angular/core";
+/**
+ * The hash algorithms, as `expo-crypto`'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 CryptoDigestAlgorithm = {
+    SHA1: 'SHA-1',
+    SHA256: 'SHA-256',
+    SHA384: 'SHA-384',
+    SHA512: 'SHA-512',
+    MD2: 'MD2',
+    MD4: 'MD4',
+    MD5: 'MD5',
+};
+/** How `digestString` writes its hash, as `expo-crypto`'s own enum: hex unless asked otherwise. */
+export const CryptoEncoding = {
+    HEX: 'hex',
+    BASE64: 'base64',
+};
+export class Crypto {
+    /** Overridden in a test to hand out identifiers that are not random. */
+    static SOURCE = new InjectionToken('angular-native.cryptoSource', {
+        factory: () => expoModule('expo-crypto', () => require('expo-crypto')),
+    });
+    native = inject(Crypto.SOURCE);
+    /** A version 4 UUID, from the platform's secure random source. */
+    randomUUID() {
+        return this.module().randomUUID();
+    }
+    /** The hash of a string, as hex or base64. */
+    async digestString(...args) {
+        return this.module().digestStringAsync(...args);
+    }
+    /** The hash of bytes, as Web Crypto's `digest` answers it. */
+    async digest(...args) {
+        return this.module().digest(...args);
+    }
+    /** Cryptographically secure random bytes, between 0 and 1024 of them. */
+    randomBytes(count) {
+        return this.module().getRandomBytes(count);
+    }
+    /** The same, as a promise. */
+    async randomBytesAsync(count) {
+        return this.module().getRandomBytesAsync(count);
+    }
+    /** Fills an integer typed array with secure random values and hands it back, as Web Crypto's. */
+    randomValues(array) {
+        return this.module().getRandomValues(array);
+    }
+    module() {
+        if (!this.native)
+            throw new Error('Crypto needs expo-crypto: npx expo install expo-crypto');
+        return this.native;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Crypto, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: Crypto });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Crypto, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=crypto.js.map

package/dist/crypto.js.map

@@ -0,0 +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"]}

package/dist/database.d.ts

@@ -0,0 +1,47 @@
+/** Enough of `SQLiteDatabase` to own it. Queries go through the database itself. */
+export interface NativeDatabase {
+    execAsync(source: string): Promise<void>;
+    getFirstAsync<T>(source: string, ...params: unknown[]): Promise<T | null>;
+    closeAsync(): Promise<void>;
+    withTransactionAsync(task: () => Promise<void>): Promise<void>;
+}
+/** One step from one schema version to the next. Run in order, each inside a transaction. */
+export interface Migration {
+    /** The version this migration produces. Must be greater than every one before it. */
+    readonly to: number;
+    readonly up: (database: NativeDatabase) => Promise<void>;
+}
+export declare class Database<T extends NativeDatabase> {
+    private readonly open;
+    private readonly migrations;
+    private opening;
+    constructor(open: () => Promise<T>, migrations?: readonly Migration[]);
+    /**
+     * The database, opened and migrated.
+     *
+     * Awaited at every call site rather than held, because the first caller is the one that pays for
+     * opening it and every caller after that is handed the same promise - including the ones that
+     * arrive while it is still opening, which is what stops two connections being made at once.
+     */
+    ready(): Promise<T>;
+    /**
+     * Close it. The next caller reopens; this is for a sign-out that has to leave nothing behind.
+     *
+     * Resolves even when the open failed: the connection was already closed by the failure, so there
+     * is nothing left to release.
+     */
+    close(): Promise<void>;
+    /** Open and migrate, closing the connection again if the migration fails. */
+    private start;
+    /**
+     * Bring the schema up to date, in order, each step in its own transaction.
+     *
+     * `user_version` is SQLite's own integer for this, so the record of where a database has got to
+     * lives in the database rather than in a table this has to create first. It is transactional,
+     * so it is set inside the migration's own transaction: the schema change and the record of it
+     * commit together or roll back together, and a migration can never be half done and recorded.
+     */
+    private migrate;
+}
+/** A database, opened on first use and migrated before the first query sees it. */
+export declare function database(name: string, migrations?: readonly Migration[]): Database<import("expo-sqlite").SQLiteDatabase>;

package/dist/database.js

@@ -0,0 +1,108 @@
+/**
+ * `database()`, bound to `expo-sqlite`.
+ *
+ * `SQLiteProvider` and `useSQLiteContext` are the documented way in and both are React: a context
+ * that opens the database, runs migrations, and closes it when the provider unmounts. The database
+ * itself is a plain object with `getAllAsync` and the rest already on it, so what is rebuilt is
+ * the *lifecycle* - opened once, migrated before anything queries, closed on request:
+ *
+ * ```ts
+ * export const notes = database('notes.db', [
+ *   { to: 1, up: (db) => db.execAsync('CREATE TABLE note (id INTEGER PRIMARY KEY, body TEXT)') },
+ * ]);
+ *
+ * const rows = await (await notes.ready()).getAllAsync<Note>('SELECT * FROM note');
+ * ```
+ *
+ * A value rather than a service, because a schema belongs to a feature rather than to an injector,
+ * and an app usually has exactly one. Opening is deferred until something asks: a database opened
+ * at startup is a file handle and a WAL journal for an app that may never read from it.
+ */
+import { expoModule } from "./native.js";
+export class Database {
+    open;
+    migrations;
+    opening = null;
+    constructor(open, migrations = []) {
+        this.open = open;
+        this.migrations = [...migrations].sort((a, b) => a.to - b.to);
+    }
+    /**
+     * The database, opened and migrated.
+     *
+     * Awaited at every call site rather than held, because the first caller is the one that pays for
+     * opening it and every caller after that is handed the same promise - including the ones that
+     * arrive while it is still opening, which is what stops two connections being made at once.
+     */
+    ready() {
+        if (this.opening)
+            return this.opening;
+        const opening = this.start();
+        this.opening = opening;
+        // A failed open is forgotten once everyone waiting on it has heard, so the next caller tries
+        // again rather than being handed the same failure for the life of the app.
+        opening.catch(() => {
+            if (this.opening === opening)
+                this.opening = null;
+        });
+        return opening;
+    }
+    /**
+     * Close it. The next caller reopens; this is for a sign-out that has to leave nothing behind.
+     *
+     * Resolves even when the open failed: the connection was already closed by the failure, so there
+     * is nothing left to release.
+     */
+    async close() {
+        const opening = this.opening;
+        this.opening = null;
+        const database = await opening?.catch(() => null);
+        await database?.closeAsync();
+    }
+    /** Open and migrate, closing the connection again if the migration fails. */
+    async start() {
+        const database = await this.open();
+        try {
+            await this.migrate(database);
+        }
+        catch (error) {
+            // The migration's own error is the one worth reporting; a failure to close after it is not.
+            await database.closeAsync().catch(() => { });
+            throw error;
+        }
+        return database;
+    }
+    /**
+     * Bring the schema up to date, in order, each step in its own transaction.
+     *
+     * `user_version` is SQLite's own integer for this, so the record of where a database has got to
+     * lives in the database rather than in a table this has to create first. It is transactional,
+     * so it is set inside the migration's own transaction: the schema change and the record of it
+     * commit together or roll back together, and a migration can never be half done and recorded.
+     */
+    async migrate(database) {
+        if (!this.migrations.length)
+            return;
+        const row = await database.getFirstAsync('PRAGMA user_version');
+        let version = row?.user_version ?? 0;
+        for (const migration of this.migrations) {
+            if (migration.to <= version)
+                continue;
+            await database.withTransactionAsync(async () => {
+                await migration.up(database);
+                await database.execAsync(`PRAGMA user_version = ${migration.to}`);
+            });
+            version = migration.to;
+        }
+    }
+}
+/** A database, opened on first use and migrated before the first query sees it. */
+export function database(name, migrations = []) {
+    return new Database(async () => {
+        const expo = expoModule('expo-sqlite', () => require('expo-sqlite'), ['ios', 'android', 'web']);
+        if (!expo)
+            throw new Error('[angular-native] expo-sqlite is not installed');
+        return expo.openDatabaseAsync(name);
+    }, migrations);
+}
+//# sourceMappingURL=database.js.map

package/dist/database.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.js","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAiBzC,MAAM,OAAO,QAAQ;IACF,IAAI,CAAmB;IACvB,UAAU,CAAuB;IAC1C,OAAO,GAAsB,IAAI,CAAC;IAE1C,YAAY,IAAsB,EAAE,aAAmC,EAAE;QACvE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,UAAU,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;OAMG;IACH,KAAK;QACH,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC,OAAO,CAAC;QACtC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,6FAA6F;QAC7F,2EAA2E;QAC3E,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE;YACjB,IAAI,IAAI,CAAC,OAAO,KAAK,OAAO;gBAAE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpD,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK;QACT,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,MAAM,QAAQ,GAAG,MAAM,OAAO,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;QAClD,MAAM,QAAQ,EAAE,UAAU,EAAE,CAAC;IAC/B,CAAC;IAED,6EAA6E;IACrE,KAAK,CAAC,KAAK;QACjB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QACnC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC/B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,4FAA4F;YAC5F,MAAM,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;YAC5C,MAAM,KAAK,CAAC;QACd,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;OAOG;IACK,KAAK,CAAC,OAAO,CAAC,QAAW;QAC/B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM;YAAE,OAAO;QAEpC,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,aAAa,CAA2B,qBAAqB,CAAC,CAAC;QAC1F,IAAI,OAAO,GAAG,GAAG,EAAE,YAAY,IAAI,CAAC,CAAC;QAErC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,IAAI,SAAS,CAAC,EAAE,IAAI,OAAO;gBAAE,SAAS;YACtC,MAAM,QAAQ,CAAC,oBAAoB,CAAC,KAAK,IAAI,EAAE;gBAC7C,MAAM,SAAS,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;gBAC7B,MAAM,QAAQ,CAAC,SAAS,CAAC,yBAAyB,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC;YACpE,CAAC,CAAC,CAAC;YACH,OAAO,GAAG,SAAS,CAAC,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;CACF;AAED,mFAAmF;AACnF,MAAM,UAAU,QAAQ,CAAC,IAAY,EAAE,aAAmC,EAAE;IAC1E,OAAO,IAAI,QAAQ,CAAuC,KAAK,IAAI,EAAE;QACnE,MAAM,IAAI,GAAG,UAAU,CACrB,aAAa,EACb,GAAG,EAAE,CAAC,OAAO,CAAC,aAAa,CAAiC,EAC5D,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,CAC1B,CAAC;QACF,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC,EAAE,UAAU,CAAC,CAAC;AACjB,CAAC","sourcesContent":["/**\n * `database()`, bound to `expo-sqlite`.\n *\n * `SQLiteProvider` and `useSQLiteContext` are the documented way in and both are React: a context\n * that opens the database, runs migrations, and closes it when the provider unmounts. The database\n * itself is a plain object with `getAllAsync` and the rest already on it, so what is rebuilt is\n * the *lifecycle* - opened once, migrated before anything queries, closed on request:\n *\n * ```ts\n * export const notes = database('notes.db', [\n *   { to: 1, up: (db) => db.execAsync('CREATE TABLE note (id INTEGER PRIMARY KEY, body TEXT)') },\n * ]);\n *\n * const rows = await (await notes.ready()).getAllAsync<Note>('SELECT * FROM note');\n * ```\n *\n * A value rather than a service, because a schema belongs to a feature rather than to an injector,\n * and an app usually has exactly one. Opening is deferred until something asks: a database opened\n * at startup is a file handle and a WAL journal for an app that may never read from it.\n */\nimport { expoModule } from './native.ts';\n\n/** Enough of `SQLiteDatabase` to own it. Queries go through the database itself. */\nexport interface NativeDatabase {\n  execAsync(source: string): Promise<void>;\n  getFirstAsync<T>(source: string, ...params: unknown[]): Promise<T | null>;\n  closeAsync(): Promise<void>;\n  withTransactionAsync(task: () => Promise<void>): Promise<void>;\n}\n\n/** One step from one schema version to the next. Run in order, each inside a transaction. */\nexport interface Migration {\n  /** The version this migration produces. Must be greater than every one before it. */\n  readonly to: number;\n  readonly up: (database: NativeDatabase) => Promise<void>;\n}\n\nexport class Database<T extends NativeDatabase> {\n  private readonly open: () => Promise<T>;\n  private readonly migrations: readonly Migration[];\n  private opening: Promise<T> | null = null;\n\n  constructor(open: () => Promise<T>, migrations: readonly Migration[] = []) {\n    this.open = open;\n    this.migrations = [...migrations].sort((a, b) => a.to - b.to);\n  }\n\n  /**\n   * The database, opened and migrated.\n   *\n   * Awaited at every call site rather than held, because the first caller is the one that pays for\n   * opening it and every caller after that is handed the same promise - including the ones that\n   * arrive while it is still opening, which is what stops two connections being made at once.\n   */\n  ready(): Promise<T> {\n    if (this.opening) return this.opening;\n    const opening = this.start();\n    this.opening = opening;\n    // A failed open is forgotten once everyone waiting on it has heard, so the next caller tries\n    // again rather than being handed the same failure for the life of the app.\n    opening.catch(() => {\n      if (this.opening === opening) this.opening = null;\n    });\n    return opening;\n  }\n\n  /**\n   * Close it. The next caller reopens; this is for a sign-out that has to leave nothing behind.\n   *\n   * Resolves even when the open failed: the connection was already closed by the failure, so there\n   * is nothing left to release.\n   */\n  async close(): Promise<void> {\n    const opening = this.opening;\n    this.opening = null;\n    const database = await opening?.catch(() => null);\n    await database?.closeAsync();\n  }\n\n  /** Open and migrate, closing the connection again if the migration fails. */\n  private async start(): Promise<T> {\n    const database = await this.open();\n    try {\n      await this.migrate(database);\n    } catch (error) {\n      // The migration's own error is the one worth reporting; a failure to close after it is not.\n      await database.closeAsync().catch(() => {});\n      throw error;\n    }\n    return database;\n  }\n\n  /**\n   * Bring the schema up to date, in order, each step in its own transaction.\n   *\n   * `user_version` is SQLite's own integer for this, so the record of where a database has got to\n   * lives in the database rather than in a table this has to create first. It is transactional,\n   * so it is set inside the migration's own transaction: the schema change and the record of it\n   * commit together or roll back together, and a migration can never be half done and recorded.\n   */\n  private async migrate(database: T): Promise<void> {\n    if (!this.migrations.length) return;\n\n    const row = await database.getFirstAsync<{ user_version: number }>('PRAGMA user_version');\n    let version = row?.user_version ?? 0;\n\n    for (const migration of this.migrations) {\n      if (migration.to <= version) continue;\n      await database.withTransactionAsync(async () => {\n        await migration.up(database);\n        await database.execAsync(`PRAGMA user_version = ${migration.to}`);\n      });\n      version = migration.to;\n    }\n  }\n}\n\n/** A database, opened on first use and migrated before the first query sees it. */\nexport function database(name: string, migrations: readonly Migration[] = []) {\n  return new Database<import('expo-sqlite').SQLiteDatabase>(async () => {\n    const expo = expoModule(\n      'expo-sqlite',\n      () => require('expo-sqlite') as typeof import('expo-sqlite'),\n      ['ios', 'android', 'web'],\n    );\n    if (!expo) throw new Error('[angular-native] expo-sqlite is not installed');\n    return expo.openDatabaseAsync(name);\n  }, migrations);\n}\n"]}

package/dist/document-picker.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `DocumentPicker`, bound to `expo-document-picker`: the system's file picker.
+ *
+ * ```ts
+ * private readonly documents = inject(DocumentPicker);
+ * const [pdf] = await this.documents.pick({ type: 'application/pdf' });
+ * ```
+ *
+ * The options are the module's own, passed through unchanged. What this adds is the thing every
+ * call site otherwise writes: a cancelled picker answers with no files rather than a result to
+ * unwrap. The system picker needs no permission, so none is asked for. Without the module
+ * installed, `pick()` answers with no files.
+ */
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+type Expo = typeof import('expo-document-picker');
+/** The module's function this service calls. The real module is one; a test provides a fake. */
+export type NativeDocumentPicker = Pick<Expo, 'getDocumentAsync'>;
+export type DocumentPickerOptions = import('expo-document-picker').DocumentPickerOptions;
+export type PickedDocument = import('expo-document-picker').DocumentPickerAsset;
+export declare class DocumentPicker {
+    /** Overridden in a test to pick files without a file system. */
+    static readonly SOURCE: InjectionToken<NativeDocumentPicker | null>;
+    private readonly native;
+    /**
+     * Opens the system picker. `type` is a MIME type or a list of them, `multiple` allows more than
+     * one file, and `copyToCacheDirectory` (the default) copies each into the app's cache so other
+     * Expo modules can read it. Empty if they cancelled.
+     */
+    pick(options?: DocumentPickerOptions): Promise<readonly PickedDocument[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentPicker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};

package/dist/document-picker.js

@@ -0,0 +1,40 @@
+/**
+ * `DocumentPicker`, bound to `expo-document-picker`: the system's file picker.
+ *
+ * ```ts
+ * private readonly documents = inject(DocumentPicker);
+ * const [pdf] = await this.documents.pick({ type: 'application/pdf' });
+ * ```
+ *
+ * The options are the module's own, passed through unchanged. What this adds is the thing every
+ * call site otherwise writes: a cancelled picker answers with no files rather than a result to
+ * unwrap. The system picker needs no permission, so none is asked for. Without the module
+ * installed, `pick()` answers with no files.
+ */
+import { InjectionToken, Service, inject } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+export class DocumentPicker {
+    /** Overridden in a test to pick files without a file system. */
+    static SOURCE = new InjectionToken('angular-native.documentPickerSource', {
+        factory: () => expoModule('expo-document-picker', () => require('expo-document-picker')),
+    });
+    native = inject(DocumentPicker.SOURCE);
+    /**
+     * Opens the system picker. `type` is a MIME type or a list of them, `multiple` allows more than
+     * one file, and `copyToCacheDirectory` (the default) copies each into the app's cache so other
+     * Expo modules can read it. Empty if they cancelled.
+     */
+    async pick(options) {
+        if (!this.native)
+            return [];
+        const result = await this.native.getDocumentAsync(options);
+        return result.canceled ? [] : result.assets;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: DocumentPicker, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: DocumentPicker });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: DocumentPicker, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=document-picker.js.map

package/dist/document-picker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-picker.js","sourceRoot":"","sources":["../src/document-picker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;;AAWzC,MAAM,OAAO,cAAc;IACzB,gEAAgE;IAChE,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,qCAAqC,EACrC;QACE,OAAO,EAAE,GAAG,EAAE,CACZ,UAAU,CAAC,sBAAsB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,sBAAsB,CAAS,CAAC;KACpF,CACF,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAExD;;;;OAIG;IACH,KAAK,CAAC,IAAI,CAAC,OAA+B;QACxC,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC3D,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;IAC9C,CAAC;uGArBU,cAAc;wGAAd,cAAc;;2FAAd,cAAc;kBAD1B,OAAO","sourcesContent":["/**\n * `DocumentPicker`, bound to `expo-document-picker`: the system's file picker.\n *\n * ```ts\n * private readonly documents = inject(DocumentPicker);\n * const [pdf] = await this.documents.pick({ type: 'application/pdf' });\n * ```\n *\n * The options are the module's own, passed through unchanged. What this adds is the thing every\n * call site otherwise writes: a cancelled picker answers with no files rather than a result to\n * unwrap. The system picker needs no permission, so none is asked for. Without the module\n * installed, `pick()` answers with no files.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport { expoModule } from './native.ts';\n\ntype Expo = typeof import('expo-document-picker');\n\n/** The module's function this service calls. The real module is one; a test provides a fake. */\nexport type NativeDocumentPicker = Pick<Expo, 'getDocumentAsync'>;\n\nexport type DocumentPickerOptions = import('expo-document-picker').DocumentPickerOptions;\nexport type PickedDocument = import('expo-document-picker').DocumentPickerAsset;\n\n@Service()\nexport class DocumentPicker {\n  /** Overridden in a test to pick files without a file system. */\n  static readonly SOURCE = new InjectionToken<NativeDocumentPicker | null>(\n    'angular-native.documentPickerSource',\n    {\n      factory: () =>\n        expoModule('expo-document-picker', () => require('expo-document-picker') as Expo),\n    },\n  );\n\n  private readonly native = inject(DocumentPicker.SOURCE);\n\n  /**\n   * Opens the system picker. `type` is a MIME type or a list of them, `multiple` allows more than\n   * one file, and `copyToCacheDirectory` (the default) copies each into the app's cache so other\n   * Expo modules can read it. Empty if they cancelled.\n   */\n  async pick(options?: DocumentPickerOptions): Promise<readonly PickedDocument[]> {\n    if (!this.native) return [];\n    const result = await this.native.getDocumentAsync(options);\n    return result.canceled ? [] : result.assets;\n  }\n}\n"]}

package/dist/dom-component.d.ts

@@ -0,0 +1,87 @@
+/**
+ * `<dom-component>`: an Angular component rendered by a browser - DOM, CSS, anything a browser
+ * runs - in a web view inside a native screen, with its inputs and outputs bound from the app's
+ * template. Expo calls this a DOM component; it is not the Web Components standard.
+ *
+ * ```ts
+ * // web/note.ts: an ordinary Angular component for the browser, in the app's own source
+ * 'use dom';
+ * @Component({ selector: 'app-note', template: '<textarea ...></textarea>', styles: [...] })
+ * export class Note {
+ *   readonly label = input('');
+ *   readonly sent = output<string>();
+ * }
+ * export default mountInWebView(Note); // from '@ng-native/web/web-view'
+ *
+ * // a native screen
+ * import note from './web/note.ts';
+ * <dom-component [src]="note" class="flex-1"
+ *   [inputs]="{ label: title() }" [outputs]="{ sent: save }" />
+ * ```
+ *
+ * The component runs in Expo's own web view (`@expo/dom-webview`, which `expo` already installs),
+ * so it is a separate JavaScript runtime from the app and only JSON crosses. It is shipped the way
+ * Expo ships its `'use dom'` components: the import is a reference to a page that Expo's dev server
+ * serves in development and `expo export:embed` bundles into the app for a release build (see
+ * `@ng-native/metro`'s `dom-component.cjs`), and the page is found where Expo finds its own.
+ *
+ * - **`inputs`** go into the page before it loads, and a changed value is sent to it afterwards
+ *   without reloading. Anything sent before the page is ready is sent again once it is.
+ * - **`outputs`** map the component's outputs, by public name, to handlers. A name the component
+ *   has no output for is an error naming the ones it does have, as `<ng-native-island>`'s is.
+ * - **Errors** the page throws reach the app's `ErrorHandler`.
+ */
+import { InjectionToken } from '@angular/core';
+import { type NativeSyntheticEvent } from '@ng-native/fabric';
+import * as i0 from "@angular/core";
+/** A handler for one of the DOM component's outputs. */
+export type DomComponentOutputHandler = (value: never) => void;
+/** The functions Expo's web view defines on its view, called with the view's tag as `this`. */
+export interface WebViewFunctions {
+    injectJavaScript(this: {
+        nativeTag: number;
+    }, script: string): Promise<void>;
+}
+/** Where the pages are, and how to reach the view once it is on screen. */
+export interface DomComponentSource {
+    /** Where Expo keeps DOM components' pages: the dev server, `www.bundle`, or an update. */
+    readonly baseUrl: string | null;
+    readonly functions: WebViewFunctions | null;
+}
+/** What native code gets for `import note from './web/note.ts'`. */
+export interface DomComponentReference {
+    readonly domComponent: string;
+}
+export declare class DomComponent {
+    /** Overridden in a test to load pages without a dev server. */
+    static readonly SOURCE: InjectionToken<DomComponentSource>;
+    private readonly native;
+    private readonly engine;
+    private readonly node;
+    private ready;
+    /** The DOM component, as imported: `import note from './web/note.ts'`. */
+    readonly src: import("@angular/core").InputSignal<DomComponentReference>;
+    /** Its inputs, by public name. JSON only: this crosses into another runtime. */
+    readonly inputs: import("@angular/core").InputSignal<Readonly<Record<string, unknown>>>;
+    /** Handlers for its outputs, by public name. */
+    readonly outputs: import("@angular/core").InputSignal<Readonly<Record<string, DomComponentOutputHandler>>>;
+    protected readonly debuggable: boolean;
+    protected readonly source: import("@angular/core").Signal<{
+        uri: string;
+    } | null>;
+    /** The file's name for an error message: the dev page names it, a release page is a hash. */
+    private readonly name;
+    /**
+     * What the page reads before it loads. The inputs are read untracked: a change to this prop
+     * reloads the page, so a changed input is sent to the running page instead.
+     */
+    protected readonly page: import("@angular/core").Signal<string>;
+    constructor();
+    protected receive(event: NativeSyntheticEvent<{
+        data: string;
+    }>): void;
+    private checkOutputs;
+    private send;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DomComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DomComponent, "dom-component", never, { "src": { "alias": "src"; "required": true; "isSignal": true; }; "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; "outputs": { "alias": "outputs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}