@symbiote-native/sharing 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+# @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, 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).
+
+## Scope: outgoing share only
+
+`expo-sharing` has two halves. This package ships one of them.
+
+| 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.
+
+Everything below describes the outgoing half.
+
+## Install
+
+```bash
+npm install @symbiote-native/sharing
+```
+
+`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
+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 |
+
+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
+[`@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.
+
+## Shape
+
+```
+src/core/                 the whole API: isAvailableAsync + shareAsync. native-module.ts
+                          resolves ExpoSharing through expo-modules-core's requireNativeModule.
+src/react/                @symbiote-native/sharing/react
+src/vue/                  @symbiote-native/sharing/vue
+src/angular/              @symbiote-native/sharing/angular
+```
+
+All three adapter entries are plain re-exports of `core/`. 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) re-exports
+rather than wraps. (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.)
+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.
+
+## Use it
+
+```ts
+import { isAvailableAsync, shareAsync } from '@symbiote-native/sharing';
+
+if (await isAvailableAsync()) {
+  await shareAsync(localFileUri, {
+    mimeType: 'application/pdf',
+    dialogTitle: 'Send the report',
+  });
+}
+```
+
+On iPad, iOS presents the sheet as a popover and needs somewhere to point it:
+
+```ts
+await shareAsync(localFileUri, {
+  anchor: { x: 40, y: 120, width: 1, height: 1 },
+});
+```
+
+## 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. |
+
+`ISharingOptions`: `mimeType` (Android), `UTI` (iOS), `dialogTitle`, `anchor` (iOS iPad).
+`ISharingAnchor`: `x`, `y`, `width`, `height`, all optional, all in points.
+
+## 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.
+- **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".
+- **`UTI` is accepted but unused.** Both native modules declare the field in their options record
+  and neither reads it in `expo-sharing@57.0.8`. It stays in the type for forward compatibility
+  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
+  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.
+
+## Test it
+
+```bash
+pnpm vitest run packages/sharing
+```
+
+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

@@ -0,0 +1 @@
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @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';

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { isAvailableAsync, shareAsync } from './sharing';
+export type { ISharingAnchor, ISharingOptions } from './types';

package/build/core/index.js

@@ -0,0 +1 @@
+export { isAvailableAsync, shareAsync } from './sharing';

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

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

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_SHARING_MODULE_NAME = 'ExpoSharing';
+export const expoSharing = requireNativeModule(EXPO_SHARING_MODULE_NAME);

package/build/core/sharing.d.ts

@@ -0,0 +1,18 @@
+import type { ISharingOptions } from './types';
+/**
+ * Whether the share sheet can be opened on this device. Resolves `true` on Android and iOS.
+ *
+ * Both native modules leave the check to the JS side, so this reports on the presence of the
+ * native module rather than on any device capability.
+ */
+export declare function isAvailableAsync(): Promise<boolean>;
+/**
+ * Open the platform share sheet for a local file, letting the user hand it to any app that can
+ * accept it.
+ *
+ * `url` must point at a file the app can read — a `file://` URI, or a path from a file-system
+ * API. Remote `http(s)` URLs are not downloaded first; share their text via the target app
+ * instead. Resolves once the sheet is dismissed, whether or not the user picked anything: no
+ * 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>;

package/build/core/sharing.js

@@ -0,0 +1,40 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoSharing } from './native-module';
+const NATIVE_MODULE_NAME = 'expo-sharing';
+/**
+ * Whether the share sheet can be opened on this device. Resolves `true` on Android and iOS.
+ *
+ * Both native modules leave the check to the JS side, so this reports on the presence of the
+ * native module rather than on any device capability.
+ */
+export async function isAvailableAsync() {
+    if (expoSharing.isAvailableAsync) {
+        return expoSharing.isAvailableAsync();
+    }
+    return !!expoSharing.shareAsync;
+}
+/**
+ * Open the platform share sheet for a local file, letting the user hand it to any app that can
+ * accept it.
+ *
+ * `url` must point at a file the app can read — a `file://` URI, or a path from a file-system
+ * API. Remote `http(s)` URLs are not downloaded first; share their text via the target app
+ * instead. Resolves once the sheet is dismissed, whether or not the user picked anything: no
+ * platform reports which app received the file, so a resolved promise is not a delivery receipt.
+ */
+export async function shareAsync(url, options = {}) {
+    ensureShareableUrl(url);
+    if (!expoSharing.shareAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'shareAsync');
+    }
+    await expoSharing.shareAsync(url, options);
+}
+// 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
+// caller's own argument named.
+function ensureShareableUrl(url) {
+    if (typeof url !== 'string' || url.length === 0) {
+        throw new Error('Invalid url provided to Sharing. Pass a non-empty local file URI or path.');
+    }
+}

package/build/core/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Where the iPad popover points. Every field is in points, relative to the presenting view;
+ * omitted fields fall back to the bottom-center of that view.
+ * @platform ios
+ */
+export type ISharingAnchor = {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+};
+export type ISharingOptions = {
+    /**
+     * MIME type of the shared file, used to pick which apps the chooser offers. Guessed from the
+     * file name when omitted, falling back to a wildcard type that offers every app.
+     * @platform android
+     */
+    mimeType?: string;
+    /**
+     * [Uniform Type Identifier](https://developer.apple.com/documentation/uniformtypeidentifiers)
+     * of the shared file.
+     *
+     * Both native modules accept the field, but neither reads it in `expo-sharing@57.0.8` — it is
+     * carried through for forward compatibility with upstream, not because it changes behavior.
+     * @platform ios
+     */
+    UTI?: string;
+    /**
+     * Title of the share dialog. Android renders it as the chooser's header; iOS assigns it to the
+     * activity controller, where most share sheets ignore it.
+     */
+    dialogTitle?: string;
+    /**
+     * Anchor rectangle for the popover iOS requires on iPad. Ignored on iPhone and on Android.
+     * @platform ios
+     */
+    anchor?: ISharingAnchor;
+};

package/build/core/types.js

@@ -0,0 +1 @@
+export {};

package/build/react/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/sharing/react: the React entry over the framework-agnostic core.
+// Both exports are stateless free functions — no per-instance state, no event stream, nothing a
+// hook could own or clean up — so this is a plain re-export, the same shape
+// packages/secure-store's React entry has for the same reason. The one part of expo-sharing that
+// WOULD need a hook (incoming share) is out of scope here; see the README.
+export * from '../core';

package/build/vue/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/vue/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/sharing/vue: the Vue entry over the framework-agnostic core. Same reasoning
+// as the React entry — no per-instance state or event stream to wire onto Vue's reactivity, so
+// this is a plain re-export.
+export * from '../core';

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

@@ -0,0 +1 @@
+export * from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,5 @@
+// @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';
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,2 @@
+export { isAvailableAsync, shareAsync } from './sharing';
+export type { ISharingAnchor, ISharingOptions } from './types';

package/build-ngc/core/index.js

@@ -0,0 +1,2 @@
+export { isAvailableAsync, shareAsync } from './sharing';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}

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

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

package/build-ngc/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_SHARING_MODULE_NAME = 'ExpoSharing';
+export const expoSharing = requireNativeModule(EXPO_SHARING_MODULE_NAME);
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGxD,MAAM,wBAAwB,GAAG,aAAa,CAAC;AAkB/C,MAAM,CAAC,MAAM,WAAW,GAAG,mBAAmB,CAAuB,wBAAwB,CAAC,CAAC"}

package/build-ngc/core/sharing.d.ts

@@ -0,0 +1,18 @@
+import type { ISharingOptions } from './types';
+/**
+ * Whether the share sheet can be opened on this device. Resolves `true` on Android and iOS.
+ *
+ * Both native modules leave the check to the JS side, so this reports on the presence of the
+ * native module rather than on any device capability.
+ */
+export declare function isAvailableAsync(): Promise<boolean>;
+/**
+ * Open the platform share sheet for a local file, letting the user hand it to any app that can
+ * accept it.
+ *
+ * `url` must point at a file the app can read — a `file://` URI, or a path from a file-system
+ * API. Remote `http(s)` URLs are not downloaded first; share their text via the target app
+ * instead. Resolves once the sheet is dismissed, whether or not the user picked anything: no
+ * 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>;

package/build-ngc/core/sharing.js

@@ -0,0 +1,41 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoSharing } from './native-module';
+const NATIVE_MODULE_NAME = 'expo-sharing';
+/**
+ * Whether the share sheet can be opened on this device. Resolves `true` on Android and iOS.
+ *
+ * Both native modules leave the check to the JS side, so this reports on the presence of the
+ * native module rather than on any device capability.
+ */
+export async function isAvailableAsync() {
+    if (expoSharing.isAvailableAsync) {
+        return expoSharing.isAvailableAsync();
+    }
+    return !!expoSharing.shareAsync;
+}
+/**
+ * Open the platform share sheet for a local file, letting the user hand it to any app that can
+ * accept it.
+ *
+ * `url` must point at a file the app can read — a `file://` URI, or a path from a file-system
+ * API. Remote `http(s)` URLs are not downloaded first; share their text via the target app
+ * instead. Resolves once the sheet is dismissed, whether or not the user picked anything: no
+ * platform reports which app received the file, so a resolved promise is not a delivery receipt.
+ */
+export async function shareAsync(url, options = {}) {
+    ensureShareableUrl(url);
+    if (!expoSharing.shareAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'shareAsync');
+    }
+    await expoSharing.shareAsync(url, options);
+}
+// 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
+// caller's own argument named.
+function ensureShareableUrl(url) {
+    if (typeof url !== 'string' || url.length === 0) {
+        throw new Error('Invalid url provided to Sharing. Pass a non-empty local file URI or path.');
+    }
+}
+//# sourceMappingURL=sharing.js.map

package/build-ngc/core/sharing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharing.js","sourceRoot":"","sources":["../../src/core/sharing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,MAAM,kBAAkB,GAAG,cAAc,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,IAAI,WAAW,CAAC,gBAAgB,EAAE,CAAC;QACjC,OAAO,WAAW,CAAC,gBAAgB,EAAE,CAAC;IACxC,CAAC;IACD,OAAO,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC;AAClC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,GAAW,EAAE,UAA2B,EAAE;IACzE,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACxB,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;QAC5B,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;IAClE,CAAC;IACD,MAAM,WAAW,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AAC7C,CAAC;AAED,8FAA8F;AAC9F,iGAAiG;AACjG,2FAA2F;AAC3F,+BAA+B;AAC/B,SAAS,kBAAkB,CAAC,GAAW;IACrC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,2EAA2E,CAAC,CAAC;IAC/F,CAAC;AACH,CAAC"}

package/build-ngc/core/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Where the iPad popover points. Every field is in points, relative to the presenting view;
+ * omitted fields fall back to the bottom-center of that view.
+ * @platform ios
+ */
+export type ISharingAnchor = {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+};
+export type ISharingOptions = {
+    /**
+     * MIME type of the shared file, used to pick which apps the chooser offers. Guessed from the
+     * file name when omitted, falling back to a wildcard type that offers every app.
+     * @platform android
+     */
+    mimeType?: string;
+    /**
+     * [Uniform Type Identifier](https://developer.apple.com/documentation/uniformtypeidentifiers)
+     * of the shared file.
+     *
+     * Both native modules accept the field, but neither reads it in `expo-sharing@57.0.8` — it is
+     * carried through for forward compatibility with upstream, not because it changes behavior.
+     * @platform ios
+     */
+    UTI?: string;
+    /**
+     * Title of the share dialog. Android renders it as the chooser's header; iOS assigns it to the
+     * activity controller, where most share sheets ignore it.
+     */
+    dialogTitle?: string;
+    /**
+     * Anchor rectangle for the popover iOS requires on iPad. Ignored on iPhone and on Android.
+     * @platform ios
+     */
+    anchor?: ISharingAnchor;
+};

package/build-ngc/core/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build-ngc/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":""}

package/native-link.json

@@ -0,0 +1,12 @@
+{
+  "android": {
+    "gradleProjectName": "expo-sharing",
+    "modules": [
+      {
+        "importPath": "expo.modules.sharing.SharingModule",
+        "className": "SharingModule",
+        "nativeName": "ExpoSharing"
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@symbiote-native/sharing",
+  "version": "0.0.1",
+  "description": "expo-sharing wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Opens the platform share sheet for a local file.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/sharing"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/sharing#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "expo-sharing": "57.0.8",
+    "expo-modules-core": "57.0.5"
+  },
+  "peerDependencies": {
+    "@symbiote-native/engine": ">=0.1.7",
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "vue": ">=3.5.0",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "^22",
+    "@angular/compiler-cli": "^22",
+    "@angular/core": "^22",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "typescript": "~6.0.0",
+    "@symbiote-native/test-utils": "0.1.6",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/engine": "0.1.7",
+    "@symbiote-native/vue": "0.3.8",
+    "@symbiote-native/angular": "0.6.1"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
+}

package/src/angular/index.ts

@@ -0,0 +1,4 @@
+// @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';

package/src/core/index.ts

@@ -0,0 +1,2 @@
+export { isAvailableAsync, shareAsync } from './sharing';
+export type { ISharingAnchor, ISharingOptions } from './types';

package/src/core/native-module.ts

@@ -0,0 +1,22 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { ISharingOptions } from './types';
+
+const EXPO_SHARING_MODULE_NAME = 'ExpoSharing';
+
+// Every member is optional — each call site checks for its presence before calling through and
+// throws an UnavailabilityError itself, matching upstream's own per-platform capability checks
+// rather than assuming the native module implements the whole surface.
+//
+// `isAvailableAsync` is genuinely absent from both native modules in expo-sharing@57.0.8: only
+// the web module (which this package does not ship) defines it. Presence of the module itself is
+// therefore what availability is read from — see isAvailableAsync in ./sharing.
+//
+// The incoming-share methods (getSharedPayloads, getResolvedSharedPayloadsAsync,
+// clearSharedPayloads) are deliberately absent from this type: reaching them needs an iOS Share
+// Extension target this package does not ship. See the README.
+export type INativeSharingModule = {
+  isAvailableAsync?(): Promise<boolean>;
+  shareAsync?(url: string, options: ISharingOptions): Promise<void>;
+};
+
+export const expoSharing = requireNativeModule<INativeSharingModule>(EXPO_SHARING_MODULE_NAME);

package/src/core/sharing.test.ts

@@ -0,0 +1,105 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_SHARING = {
+  shareAsync: vi.fn(async () => undefined),
+};
+
+// The real ExpoSharing native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless run, so the module-lookup
+// file is faked in place of expo-modules-core's runtime resolution, the same pattern
+// packages/secure-store/src/core/secure-store.test.ts uses.
+vi.mock('./native-module', () => ({
+  expoSharing: FAKE_NATIVE_SHARING,
+}));
+
+// expo-modules-core's real entry transitively imports 'react-native', whose Flow-typed source
+// Vitest's Oxc transform can't parse — so only the members used as values are faked.
+vi.mock('expo-modules-core', () => ({
+  UnavailabilityError: class UnavailabilityError extends Error {
+    constructor(moduleName: string, propertyName: string) {
+      super(`${propertyName} is not available on ${moduleName}`);
+    }
+  },
+}));
+
+const { isAvailableAsync, shareAsync } = await import('./sharing');
+
+const LOCAL_FILE_URL = 'file:///tmp/report.pdf';
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('isAvailableAsync', () => {
+  it('reports availability from the presence of the native share method', async () => {
+    await expect(isAvailableAsync()).resolves.toBe(true);
+  });
+
+  it('reports unavailable when the native module cannot share', async () => {
+    const { shareAsync: native } = FAKE_NATIVE_SHARING;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_SHARING.shareAsync = undefined;
+
+    await expect(isAvailableAsync()).resolves.toBe(false);
+
+    FAKE_NATIVE_SHARING.shareAsync = native;
+  });
+
+  it('defers to the native check when the module implements one', async () => {
+    const nativeCheck = vi.fn(async () => false);
+    Object.assign(FAKE_NATIVE_SHARING, { isAvailableAsync: nativeCheck });
+
+    await expect(isAvailableAsync()).resolves.toBe(false);
+    expect(nativeCheck).toHaveBeenCalled();
+
+    Reflect.deleteProperty(FAKE_NATIVE_SHARING, 'isAvailableAsync');
+  });
+});
+
+describe('shareAsync', () => {
+  it('passes the url and options straight through', async () => {
+    await shareAsync(LOCAL_FILE_URL, { mimeType: 'application/pdf', dialogTitle: 'Send report' });
+    expect(FAKE_NATIVE_SHARING.shareAsync).toHaveBeenCalledWith(LOCAL_FILE_URL, {
+      mimeType: 'application/pdf',
+      dialogTitle: 'Send report',
+    });
+  });
+
+  it('defaults the options to an empty object', async () => {
+    await shareAsync(LOCAL_FILE_URL);
+    expect(FAKE_NATIVE_SHARING.shareAsync).toHaveBeenCalledWith(LOCAL_FILE_URL, {});
+  });
+
+  it('forwards the iPad anchor rectangle unflattened', async () => {
+    const anchor = { x: 10, y: 20, width: 1, height: 1 };
+    await shareAsync(LOCAL_FILE_URL, { anchor });
+    expect(FAKE_NATIVE_SHARING.shareAsync).toHaveBeenCalledWith(LOCAL_FILE_URL, { anchor });
+  });
+
+  it('throws an UnavailabilityError-shaped error when the native method is absent', async () => {
+    const { shareAsync: native } = FAKE_NATIVE_SHARING;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_SHARING.shareAsync = undefined;
+
+    await expect(shareAsync(LOCAL_FILE_URL)).rejects.toThrow(
+      'shareAsync is not available on expo-sharing',
+    );
+
+    FAKE_NATIVE_SHARING.shareAsync = native;
+  });
+});
+
+// Validation happens before the native call so a bad url fails with a readable message here
+// rather than as an argument-conversion failure on iOS or a generic share failure on Android.
+describe('url validation', () => {
+  it('rejects an empty url', async () => {
+    await expect(shareAsync('')).rejects.toThrow(/Invalid url provided to Sharing/);
+    expect(FAKE_NATIVE_SHARING.shareAsync).not.toHaveBeenCalled();
+  });
+
+  it('rejects a non-string url before reaching the native module', async () => {
+    // @ts-expect-error -- the guard exists precisely for callers without type checking
+    await expect(shareAsync(undefined)).rejects.toThrow(/Invalid url provided to Sharing/);
+    expect(FAKE_NATIVE_SHARING.shareAsync).not.toHaveBeenCalled();
+  });
+});

package/src/core/sharing.ts

@@ -0,0 +1,46 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import { expoSharing } from './native-module';
+import type { ISharingOptions } from './types';
+
+const NATIVE_MODULE_NAME = 'expo-sharing';
+
+/**
+ * Whether the share sheet can be opened on this device. Resolves `true` on Android and iOS.
+ *
+ * Both native modules leave the check to the JS side, so this reports on the presence of the
+ * native module rather than on any device capability.
+ */
+export async function isAvailableAsync(): Promise<boolean> {
+  if (expoSharing.isAvailableAsync) {
+    return expoSharing.isAvailableAsync();
+  }
+  return !!expoSharing.shareAsync;
+}
+
+/**
+ * Open the platform share sheet for a local file, letting the user hand it to any app that can
+ * accept it.
+ *
+ * `url` must point at a file the app can read — a `file://` URI, or a path from a file-system
+ * API. Remote `http(s)` URLs are not downloaded first; share their text via the target app
+ * instead. Resolves once the sheet is dismissed, whether or not the user picked anything: no
+ * platform reports which app received the file, so a resolved promise is not a delivery receipt.
+ */
+export async function shareAsync(url: string, options: ISharingOptions = {}): Promise<void> {
+  ensureShareableUrl(url);
+  if (!expoSharing.shareAsync) {
+    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'shareAsync');
+  }
+  await expoSharing.shareAsync(url, options);
+}
+
+// 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
+// caller's own argument named.
+function ensureShareableUrl(url: string): void {
+  if (typeof url !== 'string' || url.length === 0) {
+    throw new Error('Invalid url provided to Sharing. Pass a non-empty local file URI or path.');
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,39 @@
+/**
+ * Where the iPad popover points. Every field is in points, relative to the presenting view;
+ * omitted fields fall back to the bottom-center of that view.
+ * @platform ios
+ */
+export type ISharingAnchor = {
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+};
+
+export type ISharingOptions = {
+  /**
+   * MIME type of the shared file, used to pick which apps the chooser offers. Guessed from the
+   * file name when omitted, falling back to a wildcard type that offers every app.
+   * @platform android
+   */
+  mimeType?: string;
+  /**
+   * [Uniform Type Identifier](https://developer.apple.com/documentation/uniformtypeidentifiers)
+   * of the shared file.
+   *
+   * Both native modules accept the field, but neither reads it in `expo-sharing@57.0.8` — it is
+   * carried through for forward compatibility with upstream, not because it changes behavior.
+   * @platform ios
+   */
+  UTI?: string;
+  /**
+   * Title of the share dialog. Android renders it as the chooser's header; iOS assigns it to the
+   * activity controller, where most share sheets ignore it.
+   */
+  dialogTitle?: string;
+  /**
+   * Anchor rectangle for the popover iOS requires on iPad. Ignored on iPhone and on Android.
+   * @platform ios
+   */
+  anchor?: ISharingAnchor;
+};

package/src/react/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/sharing/react: the React entry over the framework-agnostic core.
+// Both exports are stateless free functions — no per-instance state, no event stream, nothing a
+// hook could own or clean up — so this is a plain re-export, the same shape
+// packages/secure-store's React entry has for the same reason. The one part of expo-sharing that
+// WOULD need a hook (incoming share) is out of scope here; see the README.
+export * from '../core';

package/src/vue/index.ts

@@ -0,0 +1,4 @@
+// @symbiote-native/sharing/vue: the Vue entry over the framework-agnostic core. Same reasoning
+// as the React entry — no per-instance state or event stream to wire onto Vue's reactivity, so
+// this is a plain re-export.
+export * from '../core';