@symbiote-native/sharing 3.0.1 → 3.0.3

package/README.md

@@ -1,34 +1,29 @@
 # @symbiote-native/sharing
 
-A wrapper package for [SymbioteNative](../../README.md) that makes
-[`expo-sharing`](https://github.com/expo/expo/tree/main/packages/expo-sharing) — the platform
-share sheet for a local file — usable from **every** adapter, React, Vue, Svelte, Solid, and
-Angular, not just React. Built the same way as [`@symbiote-native/secure-store`](../secure-store): an
-`expo-modules-core`-based wrapper (see the `symbiote-expo-native-module` project skill for the
-full mechanism — why `expo-modules-core` is depended on directly and never the `expo`
-meta-package, why the upstream JS is hand-ported into `core/` rather than imported, and how
-autolinking picks up the native module).
+Let users send a file from your app to any other app, and receive files other apps share into
+yours. One API for every [SymbioteNative](../../README.md) adapter (React, Vue, Svelte, Solid and
+Angular).
 
-## Scope: outgoing share only
+It wraps [`expo-sharing`](https://github.com/expo/expo/tree/main/packages/expo-sharing) the same
+way [`@symbiote-native/secure-store`](../secure-store) wraps its upstream: `expo-modules-core` is a
+direct dependency, never the `expo` meta-package, and the upstream JS is hand-ported into `core/`.
+The mechanics live in the `symbiote-expo-native-module` project skill.
 
-`expo-sharing` has two halves. This package ships one of them.
+## Scope: outgoing and incoming share
+
+`expo-sharing` has two halves, both ported to every adapter.
 
 | Half                                                          | Upstream API                                                                                     | Here              |
 | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | ----------------- |
-| **Outgoing** — hand a local file to another app               | `shareAsync`, `isAvailableAsync`                                                                 | ✅ ported in full |
-| **Incoming** — receive files other apps share _into_ your app | `useIncomingShare`, `getSharedPayloads`, `getResolvedSharedPayloadsAsync`, `clearSharedPayloads` | ❌ not ported     |
-
-The incoming half is not a thinner JS surface — it needs a whole **iOS Share Extension target**.
-Upstream's config plugin (`plugin/src/ios/*`) generates one: a second Xcode target with its own
-build phases, its own `Info.plist`, an entitlements file, and an App Group ID shared between the
-app and the extension, plus Android intent filters on the main activity. That is native
-app-extension scaffolding, the same category this repo already parks `expo-widgets` in — no
-JS-reachable runtime module can stand in for it, and SymbioteNative has no native-target
-scaffolding story yet. So it is deliberately out of scope for this pass rather than shipped
-half-working. If you need incoming share today, use `expo-sharing` directly in a React-only app
-with Expo's own prebuild pipeline.
+| **Outgoing** - hand a local file to another app               | `shareAsync`, `isAvailableAsync`                                                                 | ported in full    |
+| **Incoming** - receive files other apps share _into_ your app | `useIncomingShare`, `getSharedPayloads`, `getResolvedSharedPayloadsAsync`, `clearSharedPayloads` | ported in full    |
 
-Everything below describes the outgoing half.
+The incoming JS runtime reads what the native module holds. The native module only holds data
+once the host app carries a share target: an **iOS Share Extension target** (a second Xcode target
+with its own `Info.plist`, entitlements and an App Group shared with the app) plus Android intent
+filters on the main activity. That target is native app scaffolding, generated upstream by
+`expo-sharing`'s config plugin (`plugin/src/ios/*`) or set up by hand. This package does not
+generate or touch it: without a share target the incoming functions return empty arrays.
 
 ## Install
 
@@ -44,62 +39,60 @@ npx @symbiote-native/cli new my-app --sharing
 npx @symbiote-native/cli add --sharing
 ```
 
-Either way: installs `@symbiote-native/sharing` and wires the native autolinking automatically —
+Either way: installs `@symbiote-native/sharing` and wires the native autolinking automatically -
 see [`@symbiote-native/cli`](../cli).
 
 <details>
-<summary>Manual install (no CLI — installing and wiring native autolinking by hand)</summary>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
 
 ```bash
 npm install @symbiote-native/sharing
 ```
 
-`expo-sharing` and `expo-modules-core` come along as regular, pinned dependencies — never install
+`expo-sharing` and `expo-modules-core` come along as regular, pinned dependencies - never install
 either yourself, and never add the `expo` meta-package to this project (it bundles its own
 Metro/Babel pipeline that conflicts with this project's own).
 
 ### Required one-time step: native autolinking wiring
 
 Unlike a plain RN native module, `expo-sharing`'s native code is discovered by
-`expo-modules-autolinking` — this needs wiring into the native host app **once**, covering this
+`expo-modules-autolinking` - this needs wiring into the native host app **once**, covering this
 package and every other `expo-modules-core` package with zero further changes:
 
 | Platform | Touches                                                                               |
 | -------- | ------------------------------------------------------------------------------------- |
-| iOS      | `ios/Podfile` — add `use_expo_modules!`                                               |
-| iOS      | `AppDelegate.swift` — Expo's runtime-bootstrap hook                                   |
-| Android  | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
-| Android  | `MainApplication.kt` — Expo's bootstrap hook, plus a native-module name map           |
+| iOS      | `ios/Podfile` - add `use_expo_modules!`                                               |
+| iOS      | `AppDelegate.swift` - Expo's runtime-bootstrap hook                                   |
+| Android  | `settings.gradle` / `app/build.gradle` - resolve and include the Expo Gradle projects |
+| Android  | `MainApplication.kt` - Expo's bootstrap hook, plus a native-module name map           |
 
 Full mechanics live in the `symbiote-expo-native-module` skill. The per-package half of that
-table — the Gradle dependency and the module map entry — is generated by
+table - the Gradle dependency and the module map entry - is generated by
 [`@symbiote-native/expo-modules-link`](../expo-modules-link) from this package's
 `native-link.json` on every install.
 
 There is no `Info.plist` usage description to add: opening the share sheet needs no iOS
 permission. On Android, the `SharingFileProvider` and the `<queries>` block the chooser needs on
 API 30+ ship inside `expo-sharing`'s own `AndroidManifest.xml` and merge into your app
-automatically once the Gradle project is included — nothing to declare by hand.
+automatically once the Gradle project is included - nothing to declare by hand.
 
 </details>
 
 ## Shape
 
 ```
-src/core/                 the whole API: isAvailableAsync + shareAsync. native-module.ts
-                          resolves ExpoSharing through expo-modules-core's requireNativeModule.
-src/angular/              @symbiote-native/sharing/angular
+src/core/     shareAsync, isAvailableAsync, the incoming payload functions, and the framework-agnostic
+              incoming-share store (refresh, AppState resync, payload comparison).
+              native-module.ts resolves ExpoSharing through expo-modules-core's requireNativeModule.
+src/react|vue|solid|svelte/  use-incoming-share: the hook over the store
+src/angular/  inject-incoming-share: the same over signals
 ```
 
-`./react`, `./vue`, `./svelte`, and `./solid` are `exports`-map aliases straight onto `src/core/` —
-no physical per-framework file. Both exports are stateless free functions — no per-instance state,
-no event stream — so there is nothing for a hook, composable, or service to wrap, the same
-reason [`@symbiote-native/secure-store`](../secure-store) does the same. (The incoming-share half
-above is exactly the part that _would_ have needed one; it is the reason this package has no
-`hooks/`, `composables/`, or `services/` folder.) `./angular` stays a physical file/subpath since
-Angular ships through a separate `ngc`/AOT build (`build-ngc/`). Import from
-`@symbiote-native/sharing` directly if you don't care which adapter you're on; the per-adapter
-subpaths exist so every wrapper package has the same import surface.
+Outgoing share is two stateless free functions, so only the incoming half has adapter code. Each
+adapter subpath re-exports `core` plus its own `useIncomingShare` (Angular: `injectIncomingShare`,
+call it in an injection context). React returns the result object, Vue a `ComputedRef`, Solid an
+`Accessor`, Svelte a `{ current }` box, Angular a `Signal`. `./angular` ships through a separate
+`ngc`/AOT build (`build-ngc/`).
 
 ## Use it
 
@@ -122,12 +115,28 @@ await shareAsync(localFileUri, {
 });
 ```
 
+Receiving what other apps shared into yours:
+
+```ts
+import { useIncomingShare } from '@symbiote-native/sharing/react';
+
+const { sharedPayloads, resolvedSharedPayloads, isResolving, error, clearSharedPayloads } =
+  useIncomingShare();
+```
+
+The hook reads the payloads synchronously, resolves them after mount, and re-reads whenever the
+app returns to the foreground. Resolving a shared URL may need the network.
+
 ## API
 
-| Export             | Signature                          | Notes                                                                                  |
-| ------------------ | ---------------------------------- | -------------------------------------------------------------------------------------- |
-| `isAvailableAsync` | `() => Promise<boolean>`           | `true` on Android and iOS. Reports on the native module, not on any device capability. |
-| `shareAsync`       | `(url, options?) => Promise<void>` | Opens the share sheet for a local file. Resolves when the sheet is dismissed.          |
+| Export                           | Signature                          | Notes                                                                                  |
+| -------------------------------- | ---------------------------------- | -------------------------------------------------------------------------------------- |
+| `isAvailableAsync`               | `() => Promise<boolean>`           | `true` on Android and iOS. Reports on the native module, not on any device capability. |
+| `shareAsync`                     | `(url, options?) => Promise<void>` | Opens the share sheet for a local file. Resolves when the sheet is dismissed.          |
+| `getSharedPayloads`              | `() => ISharePayload[]`            | Raw data shared with the app, empty when nothing was shared.                           |
+| `getResolvedSharedPayloadsAsync` | `() => Promise<IResolvedSharePayload[]>` | Adds display details per payload.                                                |
+| `clearSharedPayloads`            | `() => void`                       | Clears the data shared with the app.                                                   |
+| `useIncomingShare`               | `() => IUseIncomingShareResult`    | Payloads, resolved payloads, `isResolving`, `error`, `clearSharedPayloads`, `refreshSharePayloads`. |
 
 `ISharingOptions`: `mimeType` (Android), `UTI` (iOS), `dialogTitle`, `anchor` (iOS iPad).
 `ISharingAnchor`: `x`, `y`, `width`, `height`, all optional, all in points.
@@ -135,7 +144,7 @@ await shareAsync(localFileUri, {
 ## Notes
 
 - **`url` must be local.** A `file://` URI or a path from a file-system API. A remote `http(s)`
-  URL is not downloaded first — fetch it to a local file yourself, then share that.
+  URL is not downloaded first - fetch it to a local file yourself, then share that.
 - **A resolved promise is not a delivery receipt.** Neither platform reports which app the user
   picked, or whether they picked one at all: the promise resolves when the sheet closes. iOS
   resolves on every dismissal path, including "picked Print, then cancelled the print dialog".
@@ -144,16 +153,35 @@ await shareAsync(localFileUri, {
   with upstream, not because it changes behavior.
 - **Android runs one share at a time.** A second `shareAsync` while a chooser is open rejects
   rather than queueing.
-- **The url is validated before the native call** — non-empty string — so a bad argument fails
+- **The iOS share extension is experimental upstream.** It opens the main app target instead of
+  handling the share in its own view controller, which Apple does not officially support and may
+  stop working in a future iOS release.
+- **The url is validated before the native call**: non-empty string - so a bad argument fails
   with a readable message instead of as an argument-conversion failure on iOS or a generic
   "Failed to share the file" on Android. Upstream has no such guard.
 
+## Common questions
+
+- **Android: "Not allowed to read file under given URL" / "Failed to find configured root".** Share
+  a file from the app's own document or cache directory (for example one written with
+  [`@symbiote-native/file-system`](../file-system)). A path owned by another app, such as a media
+  library asset, can be rejected: copy it into `Paths.cache` first.
+- **Works on iOS, the receiving Android app cannot open it.** Same cause: Android hands the other
+  app a content URI, and only files in the app's directories are covered.
+- **Can I share a URL or text?** Not with `shareAsync`, which takes a local file.
+- **Did the user actually share?** Unknowable: the promise resolves when the sheet closes.
+
+Sources: [Expo docs: Sharing](https://docs.expo.dev/versions/latest/sdk/sharing/),
+[expo/expo#5933](https://github.com/expo/expo/issues/5933),
+[expo/expo#18887](https://github.com/expo/expo/issues/18887),
+[expo/expo#9222](https://github.com/expo/expo/issues/9222).
+
 ## Test it
 
 ```bash
 pnpm vitest run packages/sharing
 ```
 
-The core tests fake the native module in place of `requireNativeModule`'s runtime resolution —
+The core tests fake the native module in place of `requireNativeModule`'s runtime resolution -
 `ExpoSharing` only exists on a device, so a headless run would otherwise throw at import. The
 share sheet itself can only be verified on a device or simulator.

package/build/angular/index.d.ts

@@ -1 +1,2 @@
 export * from '../core';
+export { injectIncomingShare } from './inject-incoming-share';

package/build/angular/index.js

@@ -1,4 +1,2 @@
-// @symbiote-native/sharing/angular: the Angular entry over the framework-agnostic core. Same
-// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
-// service, so this is a plain re-export.
 export * from '../core/index.js';
+export { injectIncomingShare } from './inject-incoming-share.js';

package/build/angular/inject-incoming-share.d.ts

@@ -0,0 +1,4 @@
+import { type Signal } from '@angular/core';
+import type { IUseIncomingShareResult } from '../core/types';
+/** Angular twin of `expo-sharing`'s `useIncomingShare`, call it in an injection context */
+export declare const injectIncomingShare: () => Signal<IUseIncomingShareResult>;

package/build/angular/inject-incoming-share.js

@@ -0,0 +1,5 @@
+import { computed } from '@angular/core';
+import { createEventValueHook } from '@symbiote-native/angular';
+import { createIncomingShareHook } from '../core/incoming-share-hook.js';
+/** Angular twin of `expo-sharing`'s `useIncomingShare`, call it in an injection context */
+export const injectIncomingShare = createIncomingShareHook(createEventValueHook, box => box(), computed);

package/build/core/incoming-share-hook.d.ts

@@ -0,0 +1,4 @@
+import { INCOMING_SHARE_CHANGE } from './incoming-share-store';
+import type { IIncomingShareStore } from './incoming-share-store';
+import type { IIncomingShareSnapshot, IUseIncomingShareResult } from './types';
+export declare function createIncomingShareHook<TSnapshotBox, TResultBox>(createEventValueHook: (event: typeof INCOMING_SHARE_CHANGE, getValue: (store: IIncomingShareStore) => IIncomingShareSnapshot) => (getSource: () => IIncomingShareStore) => TSnapshotBox, readBox: (box: TSnapshotBox) => IIncomingShareSnapshot, derive: (compute: () => IUseIncomingShareResult) => TResultBox): () => TResultBox;

package/build/core/incoming-share-hook.js

@@ -0,0 +1,13 @@
+import { createIncomingShareStore, INCOMING_SHARE_CHANGE, } from './incoming-share-store.js';
+import { withShareActions } from './incoming-share-result.js';
+// Getter-shaped `useIncomingShare` for the adapters whose event-value hook takes a source getter
+// (Vue, Solid, Svelte, Angular). `readBox` unwraps that adapter's reactive box and `derive` wraps
+// the result in its own computed, React keeps its own wiring since it passes the source directly
+export function createIncomingShareHook(createEventValueHook, readBox, derive) {
+    const useShareSnapshot = createEventValueHook(INCOMING_SHARE_CHANGE, store => store.getSnapshot());
+    return function useIncomingShare() {
+        const store = createIncomingShareStore();
+        const snapshotBox = useShareSnapshot(() => store);
+        return derive(() => withShareActions(readBox(snapshotBox), store));
+    };
+}

package/build/core/incoming-share-result.d.ts

@@ -0,0 +1,3 @@
+import type { IIncomingShareStore } from './incoming-share-store';
+import type { IIncomingShareSnapshot, IUseIncomingShareResult } from './types';
+export declare function withShareActions(snapshot: IIncomingShareSnapshot, store: IIncomingShareStore): IUseIncomingShareResult;

package/build/core/incoming-share-result.js

@@ -0,0 +1,11 @@
+// Every adapter's `useIncomingShare` reports its own reactive snapshot, the two actions come
+// from the store so they are written once
+export function withShareActions(snapshot, store) {
+    return {
+        ...snapshot,
+        clearSharedPayloads: store.clear,
+        refreshSharePayloads: () => {
+            void store.refresh();
+        },
+    };
+}

package/build/core/incoming-share-store.d.ts

@@ -0,0 +1,9 @@
+import type { IEventValueSource } from '@symbiote-native/engine';
+import type { IIncomingShareSnapshot } from './types';
+export declare const INCOMING_SHARE_CHANGE = "change";
+export type IIncomingShareStore = IEventValueSource<IIncomingShareSnapshot, typeof INCOMING_SHARE_CHANGE> & {
+    getSnapshot: () => IIncomingShareSnapshot;
+    refresh: () => Promise<void>;
+    clear: () => void;
+};
+export declare function createIncomingShareStore(): IIncomingShareStore;

package/build/core/incoming-share-store.js

@@ -0,0 +1,100 @@
+import { AppState } from '@symbiote-native/engine';
+import { clearSharedPayloads, getResolvedSharedPayloadsAsync, getSharedPayloads, } from './sharing.js';
+export const INCOMING_SHARE_CHANGE = 'change';
+// Multiset comparison, so the same payloads in another order do not trigger a re-resolve
+function sharePayloadsAreEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const counts = new Map();
+    const keyOf = (item) => `${item.value}|${item.mimeType}|${item.shareType}`;
+    for (const item of a)
+        counts.set(keyOf(item), (counts.get(keyOf(item)) ?? 0) + 1);
+    for (const item of b) {
+        const count = counts.get(keyOf(item));
+        if (!count)
+            return false;
+        counts.set(keyOf(item), count - 1);
+    }
+    return true;
+}
+function toError(cause, fallbackMessage) {
+    return cause instanceof Error ? cause : new Error(fallbackMessage);
+}
+export function createIncomingShareStore() {
+    let snapshot = {
+        sharedPayloads: getSharedPayloads(),
+        resolvedSharedPayloads: [],
+        isResolving: false,
+        error: null,
+    };
+    // Starts empty, not at the first snapshot, so a first refresh with data always resolves it
+    let lastRefreshed = [];
+    const listeners = new Set();
+    let appStateSubscription = null;
+    function update(patch) {
+        snapshot = { ...snapshot, ...patch };
+        for (const listener of listeners)
+            listener(snapshot);
+    }
+    async function resolvePayloads() {
+        update({ isResolving: true });
+        try {
+            update({
+                resolvedSharedPayloads: await getResolvedSharedPayloadsAsync(),
+            });
+        }
+        catch (cause) {
+            update({
+                error: toError(cause, 'Unknown error during shared payload resolution'),
+            });
+        }
+        finally {
+            update({ isResolving: false });
+        }
+    }
+    async function refresh() {
+        try {
+            const next = getSharedPayloads();
+            // Skip the resolve when nothing changed, it can cost a network round trip
+            if (sharePayloadsAreEqual(next, lastRefreshed))
+                return;
+            lastRefreshed = next;
+            update({ sharedPayloads: next, resolvedSharedPayloads: [], error: null });
+            if (next.length > 0)
+                await resolvePayloads();
+        }
+        catch (cause) {
+            update({ error: toError(cause, 'Failed to resolve data') });
+        }
+    }
+    function start() {
+        void refresh();
+        appStateSubscription = AppState.addEventListener('change', status => {
+            if (status === 'active')
+                void refresh();
+        });
+    }
+    function stop() {
+        appStateSubscription?.remove();
+        appStateSubscription = null;
+    }
+    return {
+        getSnapshot: () => snapshot,
+        refresh,
+        clear: clearSharedPayloads,
+        addListener(_event, listener) {
+            const wasIdle = listeners.size === 0;
+            listeners.add(listener);
+            // After `add`, so the first refresh's synchronous update reaches this listener
+            if (wasIdle)
+                start();
+            return {
+                remove: () => {
+                    listeners.delete(listener);
+                    if (listeners.size === 0)
+                        stop();
+                },
+            };
+        },
+    };
+}

package/build/core/index.d.ts

@@ -1,2 +1,5 @@
-export { isAvailableAsync, shareAsync } from './sharing';
-export type { ISharingAnchor, ISharingOptions } from './types';
+export { clearSharedPayloads, getResolvedSharedPayloadsAsync, getSharedPayloads, isAvailableAsync, shareAsync, } from './sharing';
+export { createIncomingShareStore, INCOMING_SHARE_CHANGE, } from './incoming-share-store';
+export type { IIncomingShareStore } from './incoming-share-store';
+export { withShareActions } from './incoming-share-result';
+export type { IBaseResolvedSharePayload, IContentType, IIncomingShareSnapshot, IResolvedSharePayload, IShareType, ISharePayload, ISharingAnchor, ISharingOptions, ITextBasedResolvedSharePayload, IUriBasedResolvedSharePayload, IUseIncomingShareResult, } from './types';

package/build/core/index.js

@@ -1 +1,3 @@
-export { isAvailableAsync, shareAsync } from './sharing.js';
+export { clearSharedPayloads, getResolvedSharedPayloadsAsync, getSharedPayloads, isAvailableAsync, shareAsync, } from './sharing.js';
+export { createIncomingShareStore, INCOMING_SHARE_CHANGE, } from './incoming-share-store.js';
+export { withShareActions } from './incoming-share-result.js';

package/build/core/native-module.d.ts

@@ -1,6 +1,9 @@
-import type { ISharingOptions } from './types';
+import type { IResolvedSharePayload, ISharePayload, ISharingOptions } from './types';
 export type INativeSharingModule = {
     isAvailableAsync?(): Promise<boolean>;
     shareAsync?(url: string, options: ISharingOptions): Promise<void>;
+    getSharedPayloads?(): ISharePayload[];
+    getResolvedSharedPayloadsAsync?(): Promise<IResolvedSharePayload[]>;
+    clearSharedPayloads?(): void;
 };
 export declare const expoSharing: INativeSharingModule;

package/build/core/sharing.d.ts

@@ -1,4 +1,4 @@
-import type { ISharingOptions } from './types';
+import type { IResolvedSharePayload, ISharePayload, ISharingOptions } from './types';
 /**
  * Whether the share sheet can be opened on this device. Resolves `true` on Android and iOS.
  *
@@ -16,3 +16,6 @@ export declare function isAvailableAsync(): Promise<boolean>;
  * platform reports which app received the file, so a resolved promise is not a delivery receipt.
  */
 export declare function shareAsync(url: string, options?: ISharingOptions): Promise<void>;
+export declare function getSharedPayloads(): ISharePayload[];
+export declare function getResolvedSharedPayloadsAsync(): Promise<IResolvedSharePayload[]>;
+export declare function clearSharedPayloads(): void;

package/build/core/sharing.js

@@ -29,6 +29,26 @@ export async function shareAsync(url, options = {}) {
     }
     await expoSharing.shareAsync(url, options);
 }
+// Empty until the host app carries the share target (iOS Share Extension, Android intent filters)
+export function getSharedPayloads() {
+    if (!expoSharing.getSharedPayloads) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getSharedPayloads');
+    }
+    return expoSharing.getSharedPayloads();
+}
+// Adds display details per payload, resolving a shared URL may need the network
+export async function getResolvedSharedPayloadsAsync() {
+    if (!expoSharing.getResolvedSharedPayloadsAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getResolvedSharedPayloadsAsync');
+    }
+    return expoSharing.getResolvedSharedPayloadsAsync();
+}
+export function clearSharedPayloads() {
+    if (!expoSharing.clearSharedPayloads) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'clearSharedPayloads');
+    }
+    expoSharing.clearSharedPayloads();
+}
 // Not in upstream, which hands anything straight to the native module. An empty or non-string
 // url surfaces there as an argument-conversion failure on iOS and a generic "Failed to share the
 // file" on Android — both far enough from the call site to be worth failing early with the

package/build/core/types.d.ts

@@ -36,3 +36,44 @@ export type ISharingOptions = {
      */
     anchor?: ISharingAnchor;
 };
+export type IShareType = 'text' | 'url' | 'audio' | 'image' | 'video' | 'file';
+export type IContentType = 'text' | 'audio' | 'image' | 'video' | 'file' | 'website';
+/** Raw data shared with the app (android, ios) */
+export type ISharePayload = {
+    /** Message body for `text`, the URL for `url`, otherwise typically the file URI */
+    value: string;
+    shareType: IShareType;
+    /** MIME type of `value` */
+    mimeType?: string;
+};
+export type IBaseResolvedSharePayload = ISharePayload & {
+    /** Where the content can be read from (the redirect target for a URL), null for text */
+    contentUri: string | null;
+    contentType: IContentType | null;
+    contentMimeType: string | null;
+    /** The `suggestedFilename` HTTP header if present, otherwise the last path component */
+    originalName: string | null;
+    contentSize: number | null;
+};
+export type IUriBasedResolvedSharePayload = IBaseResolvedSharePayload & {
+    contentType: 'audio' | 'file' | 'video' | 'image' | 'website';
+    contentUri: string;
+};
+export type ITextBasedResolvedSharePayload = IBaseResolvedSharePayload & {
+    contentType?: 'text';
+};
+/** A payload plus the details needed to display it, resolving a URL may need the network */
+export type IResolvedSharePayload = IUriBasedResolvedSharePayload | ITextBasedResolvedSharePayload;
+export type IIncomingShareSnapshot = {
+    /** Unresolved payloads, available synchronously from the first read */
+    sharedPayloads: ISharePayload[];
+    /** Empty while resolving or when resolving failed */
+    resolvedSharedPayloads: IResolvedSharePayload[];
+    isResolving: boolean;
+    /** The error hit while resolving, null on success */
+    error: Error | null;
+};
+export type IUseIncomingShareResult = IIncomingShareSnapshot & {
+    clearSharedPayloads: () => void;
+    refreshSharePayloads: () => void;
+};

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useIncomingShare } from './use-incoming-share';

package/build/react/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useIncomingShare } from './use-incoming-share.js';

package/build/react/use-incoming-share.d.ts

@@ -0,0 +1,3 @@
+import type { IUseIncomingShareResult } from '../core/types';
+/** React twin of `expo-sharing`'s `useIncomingShare` */
+export declare function useIncomingShare(): IUseIncomingShareResult;

package/build/react/use-incoming-share.js

@@ -0,0 +1,10 @@
+import { useState } from 'react';
+import { createEventValueHook } from '@symbiote-native/react';
+import { createIncomingShareStore, INCOMING_SHARE_CHANGE, } from '../core/incoming-share-store.js';
+import { withShareActions } from '../core/incoming-share-result.js';
+const useShareSnapshot = createEventValueHook(INCOMING_SHARE_CHANGE, store => store.getSnapshot());
+/** React twin of `expo-sharing`'s `useIncomingShare` */
+export function useIncomingShare() {
+    const [store] = useState(createIncomingShareStore);
+    return withShareActions(useShareSnapshot(store), store);
+}

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useIncomingShare } from './use-incoming-share';

package/build/solid/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useIncomingShare } from './use-incoming-share.js';

package/build/solid/use-incoming-share.d.ts

@@ -0,0 +1,4 @@
+import { type Accessor } from 'solid-js';
+import type { IUseIncomingShareResult } from '../core/types';
+/** Solid twin of `expo-sharing`'s `useIncomingShare` */
+export declare const useIncomingShare: () => Accessor<IUseIncomingShareResult>;

package/build/solid/use-incoming-share.js

@@ -0,0 +1,5 @@
+import { createMemo } from 'solid-js';
+import { createEventValueHook } from '@symbiote-native/solid';
+import { createIncomingShareHook } from '../core/incoming-share-hook.js';
+/** Solid twin of `expo-sharing`'s `useIncomingShare` */
+export const useIncomingShare = createIncomingShareHook(createEventValueHook, box => box(), createMemo);

package/build/svelte/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useIncomingShare } from './use-incoming-share.svelte';

package/build/svelte/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useIncomingShare } from './use-incoming-share.svelte';

package/build/svelte/use-incoming-share.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { IUseIncomingShareResult } from '../core/types';
+type IBox<TValue> = {
+    readonly current: TValue;
+};
+/** Svelte twin of `expo-sharing`'s `useIncomingShare` */
+export declare const useIncomingShare: () => IBox<IUseIncomingShareResult>;
+export {};

package/build/svelte/use-incoming-share.svelte.js

@@ -0,0 +1,8 @@
+import { createEventValueHook } from '@symbiote-native/svelte/runes/create-event-value-hook';
+import { createIncomingShareHook } from '../core/incoming-share-hook.js';
+/** Svelte twin of `expo-sharing`'s `useIncomingShare` */
+export const useIncomingShare = createIncomingShareHook(createEventValueHook, box => box.current, compute => ({
+    get current() {
+        return compute();
+    },
+}));

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useIncomingShare } from './use-incoming-share';

package/build/vue/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useIncomingShare } from './use-incoming-share.js';

package/build/vue/use-incoming-share.d.ts

@@ -0,0 +1,4 @@
+import { type ComputedRef } from '@vue/runtime-core';
+import type { IUseIncomingShareResult } from '../core/types';
+/** Vue twin of `expo-sharing`'s `useIncomingShare` */
+export declare const useIncomingShare: () => ComputedRef<IUseIncomingShareResult>;

package/build/vue/use-incoming-share.js

@@ -0,0 +1,5 @@
+import { computed } from '@vue/runtime-core';
+import { createEventValueHook } from '@symbiote-native/vue';
+import { createIncomingShareHook } from '../core/incoming-share-hook.js';
+/** Vue twin of `expo-sharing`'s `useIncomingShare` */
+export const useIncomingShare = createIncomingShareHook(createEventValueHook, box => box.value, computed);

package/build-ngc/angular/index.d.ts

@@ -1 +1,2 @@
 export * from '../core';
+export { injectIncomingShare } from './inject-incoming-share';

package/build-ngc/angular/index.js

@@ -1,5 +1,3 @@
-// @symbiote-native/sharing/angular: the Angular entry over the framework-agnostic core. Same
-// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
-// service, so this is a plain re-export.
 export * from '../core';
+export { injectIncomingShare } from './inject-incoming-share';
 //# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,0FAA0F;AAC1F,yCAAyC;AACzC,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}

package/build-ngc/angular/inject-incoming-share.d.ts

@@ -0,0 +1,4 @@
+import { type Signal } from '@angular/core';
+import type { IUseIncomingShareResult } from '../core/types';
+/** Angular twin of `expo-sharing`'s `useIncomingShare`, call it in an injection context */
+export declare const injectIncomingShare: () => Signal<IUseIncomingShareResult>;