@sosweetham/tauri-plugin-sharehub-api 0.1.0

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 SoSweetHam
+Portions Copyright (c) 2025 Vladimir Pankratov (the share-out implementation,
+derived from tauri-plugin-sharekit, MIT)
+
+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,197 @@
+[![Crates.io Version](https://img.shields.io/crates/v/tauri-plugin-sharehub)](https://crates.io/crates/tauri-plugin-sharehub)
+[![NPM Version](https://img.shields.io/npm/v/@sosweetham%2Ftauri-plugin-sharehub-api)](https://www.npmjs.com/package/@sosweetham/tauri-plugin-sharehub-api)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+# tauri-plugin-sharehub
+
+Bidirectional native sharing for [Tauri 2](https://tauri.app) apps: share text and
+files **out** to other apps, and receive text, links, images, and files shared **in**
+from other apps as a share target.
+
+## Bidirectional
+
+Most share plugins only push content out. `sharehub` does both:
+
+- **Share OUT.** Open the system share sheet to hand text or a file to another app.
+  Backed by `UIActivityViewController` (iOS), `ACTION_SEND` (Android),
+  `NSSharingServicePicker` (macOS), and `DataTransferManager` (Windows).
+- **Share IN.** Register your app as a share target so other apps can send it text,
+  links, images, and files. On iOS a copyable Share Extension writes the shared blobs
+  plus a `manifest.json` into a shared App Group container and opens your app via a
+  deep link. On Android the plugin copies the `ACTION_SEND` / `ACTION_SEND_MULTIPLE`
+  streams into the app's files directory. Either way your app reads the queue with
+  `getPendingShares()` and pulls bytes lazily with `readSharedItem(id)`.
+
+## Platform support
+
+| Capability        | iOS | Android | macOS | Windows | Linux |
+| ----------------- | --- | ------- | ----- | ------- | ----- |
+| Share text (OUT)  | yes | yes     | yes   | yes     | no    |
+| Share file (OUT)  | yes | yes     | yes   | yes     | no    |
+| Receive shares (IN) | yes | yes   | no    | no      | no    |
+
+Desktop receive is a graceful no-op: `getPendingShares()` resolves to an empty list
+rather than throwing, so the same code runs everywhere. On Linux the share-out calls
+are no-ops.
+
+## Install
+
+Add the Rust crate to your Tauri app:
+
+```sh
+cargo add tauri-plugin-sharehub
+```
+
+Add the JavaScript guest bindings with your package manager of choice:
+
+```sh
+pnpm add @sosweetham/tauri-plugin-sharehub-api
+# or: npm add @sosweetham/tauri-plugin-sharehub-api
+# or: yarn add @sosweetham/tauri-plugin-sharehub-api
+```
+
+Register the plugin in `src-tauri/src/lib.rs`:
+
+```rust
+// src-tauri/src/lib.rs
+tauri::Builder::default()
+    .plugin(tauri_plugin_sharehub::init())
+    // ...
+```
+
+Grant the default permission set in your capability file, e.g.
+`src-tauri/capabilities/default.json`:
+
+```json
+{
+  "permissions": ["sharehub:default"]
+}
+```
+
+`sharehub:default` allows every command: `share_text`, `share_file`,
+`get_pending_shares`, `read_shared_item`, and `clear_pending_shares`.
+
+## Usage: share OUT
+
+```ts
+import { shareText, shareFile } from "@sosweetham/tauri-plugin-sharehub-api";
+
+// Share plain text.
+await shareText("Pendi is great!");
+
+// Share a file by file:// URL.
+await shareFile("file:///path/to/document.pdf", {
+  mimeType: "application/pdf",
+  title: "My Document",
+});
+
+// Anchor the share sheet (iPad / macOS, in webview coordinates).
+await shareText("Hello!", {
+  position: { x: 100, y: 200, preferredEdge: "bottom" },
+});
+```
+
+## Usage: share IN
+
+Your app receives shares by reading a queue. The reliable mechanism is to call
+`getPendingShares()` on launch and from your deep-link handler, then read bytes for the
+items you care about and clear the queue once handled.
+
+```ts
+import {
+  getPendingShares,
+  readSharedItem,
+  clearPendingShares,
+  onShare,
+} from "@sosweetham/tauri-plugin-sharehub-api";
+
+async function consumeShares() {
+  const { items } = await getPendingShares();
+  if (items.length === 0) return;
+
+  for (const item of items) {
+    if (item.kind === "text" || item.kind === "url") {
+      console.log("shared text/link:", item.text ?? item.url);
+    } else {
+      // image / file: pull the bytes lazily and wrap them in a File.
+      const buf = await readSharedItem(item.id);
+      const file = new File([buf], item.name ?? "shared", {
+        type: item.mimeType,
+      });
+      // ...upload or process `file`
+    }
+  }
+
+  // Only clear once everything has been handled successfully. A mid-flow
+  // crash leaves the share for the next launch.
+  await clearPendingShares();
+}
+
+// Best-effort: fires when a share arrives while the app is already running.
+// Silently no-ops where the platform has no live channel, so treat it as a
+// nudge on top of the launch-time `getPendingShares()` path, not a replacement.
+const unsubscribe = await onShare(() => {
+  void consumeShares();
+});
+```
+
+### Deep-link + App Group model
+
+iOS only lets a separate **Share Extension** target receive system shares, so it cannot
+ship inside the plugin: it must be a target in *your* app. The extension copies the
+shared blobs plus a `manifest.json` into a shared **App Group** container and opens your
+app at `<yourScheme>://share`. Your app handles that deep link, navigates to a share
+screen, and calls `getPendingShares()`.
+
+A copyable extension template (`ShareViewController.swift`, `Info.plist`,
+`ShareExt.entitlements`) and full setup steps live in
+[`extensions/ios/README.md`](extensions/ios/README.md). The key gotchas: the same App
+Group must be on both the host app and the extension entitlements and registered on your
+Apple Developer account, and the extension's `appScheme` must match your
+`tauri-plugin-deep-link` scheme.
+
+On **Android**, add an `ACTION_SEND` / `ACTION_SEND_MULTIPLE` intent filter to your main
+activity in `src-tauri/gen/android/app/src/main/AndroidManifest.xml` so the system lists
+your app as a share target, for example:
+
+```xml
+<intent-filter>
+  <action android:name="android.intent.action.SEND" />
+  <category android:name="android.intent.category.DEFAULT" />
+  <data android:mimeType="*/*" />
+</intent-filter>
+<intent-filter>
+  <action android:name="android.intent.action.SEND_MULTIPLE" />
+  <category android:name="android.intent.category.DEFAULT" />
+  <data android:mimeType="*/*" />
+</intent-filter>
+```
+
+The plugin copies the incoming streams into the app's files directory and exposes them
+through the same `getPendingShares()` / `readSharedItem()` API.
+
+## Type generation
+
+Every shape that crosses the JS bridge is defined once in Rust, in `src/models.rs`, and
+generated outward:
+
+```
+src/models.rs  ->  schemars JSON Schema  ->  Zod (guest-js/schemas.ts)
+```
+
+Run `pnpm generate-types` after editing `src/models.rs` to regenerate
+`guest-js/schemas.ts` (driven by the dev-only `gen` Cargo feature). Never edit
+`guest-js/schemas.ts` by hand. Inbound payloads cross from arbitrary external apps
+through messy native parsing, so `getPendingShares()` validates its result at runtime
+against the generated Zod schema before returning it. Outbound option types are
+hand-written in `guest-js/index.ts` because they are JS-constructed arguments and need
+no runtime parse.
+
+## Credits
+
+The share-OUT path is derived from Choochmeque's
+[`tauri-plugin-sharekit`](https://github.com/Choochmeque/tauri-plugin-sharekit) (MIT).
+
+## License
+
+MIT

package/dist-js/index.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+var core = require('@tauri-apps/api/core');
+var zod = require('zod');
+
+// GENERATED by `pnpm generate-types` (schemars JSON Schema -> Zod). Do not edit.
+// Source of truth: src/models.rs (SharePayload). Validates inbound share payloads.
+const sharePayloadSchema = zod.z.object({ "items": zod.z.array(zod.z.object({ "id": zod.z.string().describe("Stable id for this item within the current pending batch."), "kind": zod.z.enum(["text", "url", "image", "file"]).describe("Discriminates how to interpret the remaining fields."), "mimeType": zod.z.union([zod.z.string().describe("Best-effort MIME type for `image` / `file` items."), zod.z.null().describe("Best-effort MIME type for `image` / `file` items.")]).describe("Best-effort MIME type for `image` / `file` items.").optional(), "name": zod.z.union([zod.z.string().describe("Original display name for `image` / `file` items."), zod.z.null().describe("Original display name for `image` / `file` items.")]).describe("Original display name for `image` / `file` items.").optional(), "size": zod.z.union([zod.z.number().int().gte(0).describe("Size in bytes for `image` / `file` items, when known."), zod.z.null().describe("Size in bytes for `image` / `file` items, when known.")]).describe("Size in bytes for `image` / `file` items, when known.").optional(), "text": zod.z.union([zod.z.string().describe("Present for `text` / `url` items."), zod.z.null().describe("Present for `text` / `url` items.")]).describe("Present for `text` / `url` items.").optional(), "url": zod.z.union([zod.z.string().describe("Present for `url` items (the shared link)."), zod.z.null().describe("Present for `url` items (the shared link).")]).describe("Present for `url` items (the shared link).").optional() }).describe("One item handed to the app by an external app's share action. **Metadata only** — bytes are fetched lazily via `read_shared_item(id)`. This is the public wire shape crossing the JS bridge (the on-disk path stays behind the Rust boundary).")) }).describe("The set of items currently waiting to be consumed by the app.");
+
+// ----- Share OUT -----
+/**
+ * Opens the native sharing interface to share the specified text.
+ *
+ * ```javascript
+ * import { shareText } from "@sosweetham/tauri-plugin-sharehub-api";
+ * await shareText('I am a shared message');
+ * ```
+ */
+async function shareText(text, options) {
+    await core.invoke("plugin:sharehub|share_text", {
+        text,
+        ...options,
+    });
+}
+/**
+ * Opens the native sharing interface to share a file.
+ *
+ * ```javascript
+ * import { shareFile } from "@sosweetham/tauri-plugin-sharehub-api";
+ * await shareFile('file:///path/to/file.pdf', {
+ *   mimeType: 'application/pdf',
+ *   title: 'Document.pdf'
+ * });
+ * ```
+ * @param url - The file URL to share (must be a file:// URL)
+ * @param options - Optional settings including MIME type and title
+ */
+async function shareFile(url, options) {
+    await core.invoke("plugin:sharehub|share_file", {
+        url,
+        ...options,
+    });
+}
+// ----- Share IN (receive / share-target) -----
+/**
+ * Returns the items currently waiting to be consumed by this app (metadata only).
+ * Does **not** clear the queue — call {@link clearPendingShares} once handled, so a
+ * mid-flow crash leaves the share for next launch.
+ *
+ * The result is validated against {@link sharePayloadSchema} (generated from the Rust
+ * models): this is the one boundary where data originates from arbitrary external apps
+ * via messy native parsing, so the runtime check earns its keep. On platforms without
+ * an in-app share target (desktop) this resolves to an empty list rather than throwing.
+ */
+async function getPendingShares() {
+    const raw = await core.invoke("plugin:sharehub|get_pending_shares");
+    return sharePayloadSchema.parse(raw);
+}
+/**
+ * Reads the raw bytes of a pending `image`/`file` item by id, returned as an
+ * `ArrayBuffer`. Wrap it in a `File`/`Blob` to upload:
+ *
+ * ```javascript
+ * const buf = await readSharedItem(item.id);
+ * const file = new File([buf], item.name ?? "shared", { type: item.mimeType });
+ * ```
+ */
+async function readSharedItem(id) {
+    return await core.invoke("plugin:sharehub|read_shared_item", { id });
+}
+/**
+ * Clears the pending queue and removes the copied blobs. Call only after the items
+ * have been successfully handled.
+ */
+async function clearPendingShares() {
+    await core.invoke("plugin:sharehub|clear_pending_shares");
+}
+/**
+ * Best-effort subscription for shares that arrive while the app is already running.
+ *
+ * The **reliable** mechanism is {@link getPendingShares} on launch plus your app's
+ * deep-link handler (the share extension / intent opens your app, you navigate to a
+ * share screen and call `getPendingShares`). This listener is only a foreground
+ * nudge and silently no-ops where the platform has no live channel.
+ *
+ * @returns an unsubscribe function.
+ */
+async function onShare(cb) {
+    try {
+        const listener = await core.addPluginListener("sharehub", "received", (payload) => cb(payload));
+        return () => {
+            void listener.unregister();
+        };
+    }
+    catch {
+        return () => { };
+    }
+}
+
+exports.clearPendingShares = clearPendingShares;
+exports.getPendingShares = getPendingShares;
+exports.onShare = onShare;
+exports.readSharedItem = readSharedItem;
+exports.shareFile = shareFile;
+exports.shareText = shareText;

package/dist-js/index.d.ts

@@ -0,0 +1,82 @@
+import { type SharePayload } from "./schemas";
+export type { SharePayload };
+export type SharedItem = SharePayload["items"][number];
+export type SharedItemKind = SharedItem["kind"];
+export interface SharePosition {
+    x: number;
+    y: number;
+    /** macOS only: which edge the picker appears from */
+    preferredEdge?: "top" | "bottom" | "left" | "right";
+}
+export interface ShareTextOptions {
+    /** Android only */
+    mimeType?: string;
+    /** Position for the share sheet (iPad/macOS only) */
+    position?: SharePosition;
+}
+export interface ShareFileOptions {
+    mimeType?: string;
+    title?: string;
+    /** Position for the share sheet (iPad/macOS only) */
+    position?: SharePosition;
+}
+/**
+ * Opens the native sharing interface to share the specified text.
+ *
+ * ```javascript
+ * import { shareText } from "@sosweetham/tauri-plugin-sharehub-api";
+ * await shareText('I am a shared message');
+ * ```
+ */
+export declare function shareText(text: string, options?: ShareTextOptions): Promise<void>;
+/**
+ * Opens the native sharing interface to share a file.
+ *
+ * ```javascript
+ * import { shareFile } from "@sosweetham/tauri-plugin-sharehub-api";
+ * await shareFile('file:///path/to/file.pdf', {
+ *   mimeType: 'application/pdf',
+ *   title: 'Document.pdf'
+ * });
+ * ```
+ * @param url - The file URL to share (must be a file:// URL)
+ * @param options - Optional settings including MIME type and title
+ */
+export declare function shareFile(url: string, options?: ShareFileOptions): Promise<void>;
+/**
+ * Returns the items currently waiting to be consumed by this app (metadata only).
+ * Does **not** clear the queue — call {@link clearPendingShares} once handled, so a
+ * mid-flow crash leaves the share for next launch.
+ *
+ * The result is validated against {@link sharePayloadSchema} (generated from the Rust
+ * models): this is the one boundary where data originates from arbitrary external apps
+ * via messy native parsing, so the runtime check earns its keep. On platforms without
+ * an in-app share target (desktop) this resolves to an empty list rather than throwing.
+ */
+export declare function getPendingShares(): Promise<SharePayload>;
+/**
+ * Reads the raw bytes of a pending `image`/`file` item by id, returned as an
+ * `ArrayBuffer`. Wrap it in a `File`/`Blob` to upload:
+ *
+ * ```javascript
+ * const buf = await readSharedItem(item.id);
+ * const file = new File([buf], item.name ?? "shared", { type: item.mimeType });
+ * ```
+ */
+export declare function readSharedItem(id: string): Promise<ArrayBuffer>;
+/**
+ * Clears the pending queue and removes the copied blobs. Call only after the items
+ * have been successfully handled.
+ */
+export declare function clearPendingShares(): Promise<void>;
+/**
+ * Best-effort subscription for shares that arrive while the app is already running.
+ *
+ * The **reliable** mechanism is {@link getPendingShares} on launch plus your app's
+ * deep-link handler (the share extension / intent opens your app, you navigate to a
+ * share screen and call `getPendingShares`). This listener is only a foreground
+ * nudge and silently no-ops where the platform has no live channel.
+ *
+ * @returns an unsubscribe function.
+ */
+export declare function onShare(cb: (payload: SharePayload) => void): Promise<() => void>;

package/dist-js/index.js

@@ -0,0 +1,98 @@
+import { invoke, addPluginListener } from '@tauri-apps/api/core';
+import { z } from 'zod';
+
+// GENERATED by `pnpm generate-types` (schemars JSON Schema -> Zod). Do not edit.
+// Source of truth: src/models.rs (SharePayload). Validates inbound share payloads.
+const sharePayloadSchema = z.object({ "items": z.array(z.object({ "id": z.string().describe("Stable id for this item within the current pending batch."), "kind": z.enum(["text", "url", "image", "file"]).describe("Discriminates how to interpret the remaining fields."), "mimeType": z.union([z.string().describe("Best-effort MIME type for `image` / `file` items."), z.null().describe("Best-effort MIME type for `image` / `file` items.")]).describe("Best-effort MIME type for `image` / `file` items.").optional(), "name": z.union([z.string().describe("Original display name for `image` / `file` items."), z.null().describe("Original display name for `image` / `file` items.")]).describe("Original display name for `image` / `file` items.").optional(), "size": z.union([z.number().int().gte(0).describe("Size in bytes for `image` / `file` items, when known."), z.null().describe("Size in bytes for `image` / `file` items, when known.")]).describe("Size in bytes for `image` / `file` items, when known.").optional(), "text": z.union([z.string().describe("Present for `text` / `url` items."), z.null().describe("Present for `text` / `url` items.")]).describe("Present for `text` / `url` items.").optional(), "url": z.union([z.string().describe("Present for `url` items (the shared link)."), z.null().describe("Present for `url` items (the shared link).")]).describe("Present for `url` items (the shared link).").optional() }).describe("One item handed to the app by an external app's share action. **Metadata only** — bytes are fetched lazily via `read_shared_item(id)`. This is the public wire shape crossing the JS bridge (the on-disk path stays behind the Rust boundary).")) }).describe("The set of items currently waiting to be consumed by the app.");
+
+// ----- Share OUT -----
+/**
+ * Opens the native sharing interface to share the specified text.
+ *
+ * ```javascript
+ * import { shareText } from "@sosweetham/tauri-plugin-sharehub-api";
+ * await shareText('I am a shared message');
+ * ```
+ */
+async function shareText(text, options) {
+    await invoke("plugin:sharehub|share_text", {
+        text,
+        ...options,
+    });
+}
+/**
+ * Opens the native sharing interface to share a file.
+ *
+ * ```javascript
+ * import { shareFile } from "@sosweetham/tauri-plugin-sharehub-api";
+ * await shareFile('file:///path/to/file.pdf', {
+ *   mimeType: 'application/pdf',
+ *   title: 'Document.pdf'
+ * });
+ * ```
+ * @param url - The file URL to share (must be a file:// URL)
+ * @param options - Optional settings including MIME type and title
+ */
+async function shareFile(url, options) {
+    await invoke("plugin:sharehub|share_file", {
+        url,
+        ...options,
+    });
+}
+// ----- Share IN (receive / share-target) -----
+/**
+ * Returns the items currently waiting to be consumed by this app (metadata only).
+ * Does **not** clear the queue — call {@link clearPendingShares} once handled, so a
+ * mid-flow crash leaves the share for next launch.
+ *
+ * The result is validated against {@link sharePayloadSchema} (generated from the Rust
+ * models): this is the one boundary where data originates from arbitrary external apps
+ * via messy native parsing, so the runtime check earns its keep. On platforms without
+ * an in-app share target (desktop) this resolves to an empty list rather than throwing.
+ */
+async function getPendingShares() {
+    const raw = await invoke("plugin:sharehub|get_pending_shares");
+    return sharePayloadSchema.parse(raw);
+}
+/**
+ * Reads the raw bytes of a pending `image`/`file` item by id, returned as an
+ * `ArrayBuffer`. Wrap it in a `File`/`Blob` to upload:
+ *
+ * ```javascript
+ * const buf = await readSharedItem(item.id);
+ * const file = new File([buf], item.name ?? "shared", { type: item.mimeType });
+ * ```
+ */
+async function readSharedItem(id) {
+    return await invoke("plugin:sharehub|read_shared_item", { id });
+}
+/**
+ * Clears the pending queue and removes the copied blobs. Call only after the items
+ * have been successfully handled.
+ */
+async function clearPendingShares() {
+    await invoke("plugin:sharehub|clear_pending_shares");
+}
+/**
+ * Best-effort subscription for shares that arrive while the app is already running.
+ *
+ * The **reliable** mechanism is {@link getPendingShares} on launch plus your app's
+ * deep-link handler (the share extension / intent opens your app, you navigate to a
+ * share screen and call `getPendingShares`). This listener is only a foreground
+ * nudge and silently no-ops where the platform has no live channel.
+ *
+ * @returns an unsubscribe function.
+ */
+async function onShare(cb) {
+    try {
+        const listener = await addPluginListener("sharehub", "received", (payload) => cb(payload));
+        return () => {
+            void listener.unregister();
+        };
+    }
+    catch {
+        return () => { };
+    }
+}
+
+export { clearPendingShares, getPendingShares, onShare, readSharedItem, shareFile, shareText };

package/dist-js/schemas.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const sharePayloadSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<["text", "url", "image", "file"]>;
+        mimeType: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+        name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+        size: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNull]>>;
+        text: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+        url: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "text" | "url" | "image" | "file";
+        text?: string | null | undefined;
+        url?: string | null | undefined;
+        mimeType?: string | null | undefined;
+        name?: string | null | undefined;
+        size?: number | null | undefined;
+    }, {
+        id: string;
+        kind: "text" | "url" | "image" | "file";
+        text?: string | null | undefined;
+        url?: string | null | undefined;
+        mimeType?: string | null | undefined;
+        name?: string | null | undefined;
+        size?: number | null | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    items: {
+        id: string;
+        kind: "text" | "url" | "image" | "file";
+        text?: string | null | undefined;
+        url?: string | null | undefined;
+        mimeType?: string | null | undefined;
+        name?: string | null | undefined;
+        size?: number | null | undefined;
+    }[];
+}, {
+    items: {
+        id: string;
+        kind: "text" | "url" | "image" | "file";
+        text?: string | null | undefined;
+        url?: string | null | undefined;
+        mimeType?: string | null | undefined;
+        name?: string | null | undefined;
+        size?: number | null | undefined;
+    }[];
+}>;
+export type SharePayload = z.infer<typeof sharePayloadSchema>;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@sosweetham/tauri-plugin-sharehub-api",
+  "version": "0.1.0",
+  "description": "Share content to and from Tauri 2 apps through the native OS share UI: share out (text/files) and receive shares in (text, links, images, files) as a share target. iOS, Android, macOS, Windows.",
+  "license": "MIT",
+  "author": "SoSweetHam <sosweetham@gmail.com>",
+  "type": "module",
+  "types": "./dist-js/index.d.ts",
+  "main": "./dist-js/index.cjs",
+  "module": "./dist-js/index.js",
+  "exports": {
+    "types": "./dist-js/index.d.ts",
+    "import": "./dist-js/index.js",
+    "require": "./dist-js/index.cjs"
+  },
+  "files": [
+    "dist-js",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sosweetham/tauri-plugin-sharehub.git"
+  },
+  "homepage": "https://github.com/sosweetham/tauri-plugin-sharehub#readme",
+  "bugs": {
+    "url": "https://github.com/sosweetham/tauri-plugin-sharehub/issues"
+  },
+  "keywords": [
+    "tauri",
+    "tauri-plugin",
+    "share",
+    "share-target",
+    "share-sheet",
+    "ios",
+    "android",
+    "macos",
+    "windows"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@tauri-apps/api": ">=2.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^11.1.6",
+    "json-schema-to-zod": "^2.6.0",
+    "rollup": "^4.9.6",
+    "tslib": "^2.6.2",
+    "typescript": "^5.3.3"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "check-types": "tsc --noEmit",
+    "generate-types": "node scripts/gen-zod.mjs"
+  }
+}