@symbiote-native/clipboard 3.0.2 → 3.0.3

package/README.md

@@ -1,11 +1,11 @@
 # @symbiote-native/clipboard
 
 A wrapper package for [SymbioteNative](../../README.md) that makes
-[`expo-clipboard`](https://docs.expo.dev/versions/latest/sdk/clipboard/) — read/write clipboard
-text, URLs, and images, plus a clipboard-change listener — usable from **every** adapter: React,
+[`expo-clipboard`](https://docs.expo.dev/versions/latest/sdk/clipboard/) - read/write clipboard
+text, URLs, and images, plus a clipboard-change listener - usable from **every** adapter: React,
 Vue, Svelte, Solid, and Angular, not just React. Unlike `@symbiote-native/sensors`, which is all
 `DeviceSensor`-shaped classes plus one free-function module (`Pedometer`), clipboard is closer to
-`@symbiote-native/local-auth`'s shape — mostly stateless async functions — plus **one**
+`@symbiote-native/local-auth`'s shape - mostly stateless async functions - plus **one**
 listener-based subscription (`addClipboardListener`) that each adapter wraps in its own
 mount/unmount lifecycle (`useClipboard`).
 
@@ -23,38 +23,38 @@ npx @symbiote-native/cli new my-app --clipboard
 npx @symbiote-native/cli add --clipboard
 ```
 
-Either way: installs `@symbiote-native/clipboard` and wires the native autolinking automatically —
+Either way: installs `@symbiote-native/clipboard` 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/clipboard
 ```
 
 Depends on `expo-clipboard` and `expo-modules-core` directly (regular dependencies, pinned to an
-exact version — never a caret range, since this package's `core/` is hand-ported against one
+exact version - never a caret range, since this package's `core/` is hand-ported against one
 specific native API shape and a newer resolve could silently drift the two apart). Never install
-`expo-clipboard` yourself, and never add the `expo` meta-package to this project — it bundles its
+`expo-clipboard` 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-clipboard`'s native code is discovered by
-`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism - this needs wiring
 into the native host app **once**, covering this package and every other `expo-modules-core`
 package (`@symbiote-native/sensors`, `@symbiote-native/local-auth`) 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 hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+| 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 hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
 
 Full mechanics live in the `symbiote-expo-native-module` skill. Clipboard itself needs no
-`Info.plist`/`AndroidManifest.xml` permission entry on either platform — reading/writing the
+`Info.plist`/`AndroidManifest.xml` permission entry on either platform - reading/writing the
 clipboard requires no platform permission string.
 
 </details>
@@ -67,19 +67,19 @@ src/core/               getStringAsync/setStringAsync/hasStringAsync, getUrlAsyn
                          addClipboardListener/removeClipboardListener. native-module.ts resolves
                          the ExpoClipboard native module via expo-modules-core's
                          requireNativeModule.
-src/react/hooks/         @symbiote-native/clipboard/react   — useClipboard
-src/vue/composables/     @symbiote-native/clipboard/vue     — useClipboard (same name)
-src/svelte/runes/        @symbiote-native/clipboard/svelte  — useClipboard (same name)
-src/solid/primitives/    @symbiote-native/clipboard/solid   — createClipboard (Solid says
+src/react/hooks/         @symbiote-native/clipboard/react   - useClipboard
+src/vue/composables/     @symbiote-native/clipboard/vue     - useClipboard (same name)
+src/svelte/runes/        @symbiote-native/clipboard/svelte  - useClipboard (same name)
+src/solid/primitives/    @symbiote-native/clipboard/solid   - createClipboard (Solid says
                                                               create*, not use*)
-src/angular/services/    @symbiote-native/clipboard/angular — ClipboardService
+src/angular/services/    @symbiote-native/clipboard/angular - ClipboardService
 ```
 
 Every function except the listener is plain stateless async and re-exported as-is. The listener
 subscription (`addClipboardListener`) lives once in `core`, framework-agnostic; each adapter's
 `useClipboard` hook/composable/rune, Solid's `createClipboard`, and `ClipboardService.connect()`
 are thin mount/unmount wrappers (a DI-scoped `effect()` for Angular, a body-level subscription plus
-`onCleanup` for Solid) around that same subscription — the plumbing is written once and shared by
+`onCleanup` for Solid) around that same subscription - the plumbing is written once and shared by
 every adapter.
 
 ## Use it
@@ -93,7 +93,7 @@ import {
 ```
 
 `useClipboard()`'s event only carries the clipboard's changed content _types_
-(`IClipboardEvent.contentTypes`), never the string itself — every adapter's demo screen treats a
+(`IClipboardEvent.contentTypes`), never the string itself - every adapter's demo screen treats a
 change as a cue to re-fetch via `getStringAsync()`, not a value to render directly.
 
 ```tsx
@@ -234,10 +234,10 @@ export class ClipboardScreen {
 }
 ```
 
-These are trimmed from the real demo screens — `examples/expo-react/screens/ClipboardScreen.tsx`,
+These are trimmed from the real demo screens - `examples/expo-react/screens/ClipboardScreen.tsx`,
 `examples/expo-vue-sfc/screens/ClipboardScreen.vue`, `examples/expo-vue-tsx/screens/ClipboardScreen.tsx`,
 `examples/expo-svelte/screens/ClipboardScreen.svelte`, `examples/expo-solid/screens/ClipboardScreen.tsx`,
-`examples/expo-angular/src/screens/ClipboardScreen.ts` — which additionally show `hasStringAsync()`
+`examples/expo-angular/src/screens/ClipboardScreen.ts` - which additionally show `hasStringAsync()`
 status badges and, iOS-only, the `getUrlAsync`/`setUrlAsync`/`hasUrlAsync` URL surface.
 
 ## API
@@ -257,7 +257,8 @@ removeClipboardListener(subscription: EventSubscription) // deprecated, use subs
 ```
 
 Plus `ContentType`, `StringFormat`, `IGetStringOptions`, `ISetStringOptions`, `IGetImageOptions`,
-`IClipboardImage`, `IClipboardEvent` — ported from upstream's `Clipboard.types.ts`, renamed with
+`IClipboardImage`, `IClipboardEvent`, `IAcceptedContentType`, `ICornerStyle`, `IDisplayMode` and
+`IPasteEventPayload`, ported from upstream's `Clipboard.types.ts`, renamed with
 this repo's `I`-prefix convention for exported types (`ts-js-best-practices`); `ContentType` and
 `StringFormat` stay unprefixed enums, matching `AuthenticationType`/`SecurityLevel` in
 `@symbiote-native/local-auth`.
@@ -284,15 +285,48 @@ import { ClipboardService } from '@symbiote-native/clipboard/angular';
 readonly clipboardEvent = inject(ClipboardService).connect(); // Signal<IClipboardEvent | null>
 ```
 
-`ClipboardPasteButton` (upstream's native paste-button view component, iOS 16+) is **not**
-ported — out of scope for this pass. If it's ever wrapped, it follows
-`symbiote-third-party-native-view`, not this package's `expo-modules-core` recipe.
+### ClipboardPasteButton
+
+`UIPasteControl`, iOS 16+, lets the user paste without the system permission prompt. It renders
+nothing on Android, and `isPasteButtonAvailable` (from the package root) tells whether the device
+supports it. Give it a width and a height in `style`, or it does not appear. Apple restricts the
+control, so `style` takes no `backgroundColor`, `borderRadius` or `color`: use `backgroundColor`,
+`foregroundColor`, `cornerStyle` and `displayMode` instead.
+
+```tsx
+// React, `onPress` gets `{ type: 'text', text }` or `{ type: 'image', data, size }`
+import { ClipboardPasteButton, isPasteButtonAvailable } from '@symbiote-native/clipboard/react';
+
+{isPasteButtonAvailable && (
+  <ClipboardPasteButton
+    style={{ width: 160, height: 44 }}
+    cornerStyle="capsule"
+    acceptedContentTypes={['plain-text', 'image']}
+    onPress={data => (data.type === 'text' ? setText(data.text) : setImage(data.data))}
+  />
+)}
+```
+
+Vue takes `@press`, Angular `[onPress]`, Svelte and Solid `onPress`, all from their own entry
+(`ClipboardPasteButton`). It is an Expo native view reached through `requireNativeViewManager`,
+which the core registers when the button renders. The pasted payload is read through a guard in
+`toPasteEventPayload`, a malformed native event is dropped.
+
+## Common questions
+
+- **Empty string on iOS.** A denied paste on iOS 16+ returns `''`, indistinguishable from an empty
+  clipboard; no error is thrown.
+- **Avoid the paste prompt?** Use `ClipboardPasteButton` (wraps `UIPasteControl`).
+- **Copy an image?** `setImageAsync` takes a base64 string.
+
+Sources: [Expo docs: Clipboard](https://docs.expo.dev/versions/latest/sdk/clipboard/),
+[expo/expo#40189](https://github.com/expo/expo/issues/40189).
 
 ## Test it
 
 Tests exercise the JS layer only, against a fake native module in place of the real
 `requireNativeModule` resolution (`src/core/**/*.test.ts`,
-`src/{react,vue,svelte,solid,angular}/**/*.test.{ts,tsx}`) — no Fabric/Descriptor angle at all,
+`src/{react,vue,svelte,solid,angular}/**/*.test.{ts,tsx}`) - no Fabric/Descriptor angle at all,
 since clipboard
 is a pure async-function + one-listener surface, never a view. Native rendering itself is verified
 on-device (see the parent [README](../../README.md) for the project's testing model).
@@ -300,4 +334,4 @@ on-device (see the parent [README](../../README.md) for the project's testing mo
 Native autolinking wiring (Android's 3-layer registration, iOS Podfile/pod install) is done across
 all six `examples/expo-*` canary apps. It isn't wired into the public non-Expo canaries
 (`examples/react`, `examples/vue-sfc`, `examples/vue-tsx`, `examples/svelte`, `examples/solid`,
-`examples/angular`) yet — those don't depend on any `expo-modules-core` package today.
+`examples/angular`) yet - those don't depend on any `expo-modules-core` package today.

package/build/angular/clipboard-paste-button/index.d.ts

@@ -0,0 +1,15 @@
+import { NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+import type { IClipboardPasteButtonProps } from '../../core/clipboard-paste-button';
+/** Angular twin of `expo-clipboard`'s `ClipboardPasteButton` (`UIPasteControl`), iOS only */
+export declare class ClipboardPasteButton extends NativeViewBase {
+    onPress: IClipboardPasteButtonProps['onPress'];
+    backgroundColor?: IClipboardPasteButtonProps['backgroundColor'];
+    foregroundColor?: IClipboardPasteButtonProps['foregroundColor'];
+    cornerStyle?: IClipboardPasteButtonProps['cornerStyle'];
+    displayMode?: IClipboardPasteButtonProps['displayMode'];
+    imageOptions?: IClipboardPasteButtonProps['imageOptions'];
+    acceptedContentTypes?: IClipboardPasteButtonProps['acceptedContentTypes'];
+    protected readonly propNames: readonly ["onPress", "backgroundColor", "foregroundColor", "cornerStyle", "displayMode", "imageOptions", "acceptedContentTypes"];
+    protected renderView(props: object): IDescriptor | null;
+}

package/build/angular/clipboard-paste-button/index.js

@@ -0,0 +1,119 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { DescriptorOutlet, NativeViewBase } from '@symbiote-native/angular';
+import { renderClipboardPasteButton } from '../../core/clipboard-paste-button.js';
+/** Angular twin of `expo-clipboard`'s `ClipboardPasteButton` (`UIPasteControl`), iOS only */
+let ClipboardPasteButton = (() => {
+    let _classDecorators = [Component({
+            selector: 'ClipboardPasteButton',
+            standalone: true,
+            imports: [DescriptorOutlet],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            template: `@if (descriptor; as node) {
+    <symbiote-descriptor-outlet [node]="node" />
+  }`,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = NativeViewBase;
+    let _onPress_decorators;
+    let _onPress_initializers = [];
+    let _onPress_extraInitializers = [];
+    let _backgroundColor_decorators;
+    let _backgroundColor_initializers = [];
+    let _backgroundColor_extraInitializers = [];
+    let _foregroundColor_decorators;
+    let _foregroundColor_initializers = [];
+    let _foregroundColor_extraInitializers = [];
+    let _cornerStyle_decorators;
+    let _cornerStyle_initializers = [];
+    let _cornerStyle_extraInitializers = [];
+    let _displayMode_decorators;
+    let _displayMode_initializers = [];
+    let _displayMode_extraInitializers = [];
+    let _imageOptions_decorators;
+    let _imageOptions_initializers = [];
+    let _imageOptions_extraInitializers = [];
+    let _acceptedContentTypes_decorators;
+    let _acceptedContentTypes_initializers = [];
+    let _acceptedContentTypes_extraInitializers = [];
+    var ClipboardPasteButton = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _onPress_decorators = [Input({ required: true })];
+            _backgroundColor_decorators = [Input()];
+            _foregroundColor_decorators = [Input()];
+            _cornerStyle_decorators = [Input()];
+            _displayMode_decorators = [Input()];
+            _imageOptions_decorators = [Input()];
+            _acceptedContentTypes_decorators = [Input()];
+            __esDecorate(null, null, _onPress_decorators, { kind: "field", name: "onPress", static: false, private: false, access: { has: obj => "onPress" in obj, get: obj => obj.onPress, set: (obj, value) => { obj.onPress = value; } }, metadata: _metadata }, _onPress_initializers, _onPress_extraInitializers);
+            __esDecorate(null, null, _backgroundColor_decorators, { kind: "field", name: "backgroundColor", static: false, private: false, access: { has: obj => "backgroundColor" in obj, get: obj => obj.backgroundColor, set: (obj, value) => { obj.backgroundColor = value; } }, metadata: _metadata }, _backgroundColor_initializers, _backgroundColor_extraInitializers);
+            __esDecorate(null, null, _foregroundColor_decorators, { kind: "field", name: "foregroundColor", static: false, private: false, access: { has: obj => "foregroundColor" in obj, get: obj => obj.foregroundColor, set: (obj, value) => { obj.foregroundColor = value; } }, metadata: _metadata }, _foregroundColor_initializers, _foregroundColor_extraInitializers);
+            __esDecorate(null, null, _cornerStyle_decorators, { kind: "field", name: "cornerStyle", static: false, private: false, access: { has: obj => "cornerStyle" in obj, get: obj => obj.cornerStyle, set: (obj, value) => { obj.cornerStyle = value; } }, metadata: _metadata }, _cornerStyle_initializers, _cornerStyle_extraInitializers);
+            __esDecorate(null, null, _displayMode_decorators, { kind: "field", name: "displayMode", static: false, private: false, access: { has: obj => "displayMode" in obj, get: obj => obj.displayMode, set: (obj, value) => { obj.displayMode = value; } }, metadata: _metadata }, _displayMode_initializers, _displayMode_extraInitializers);
+            __esDecorate(null, null, _imageOptions_decorators, { kind: "field", name: "imageOptions", static: false, private: false, access: { has: obj => "imageOptions" in obj, get: obj => obj.imageOptions, set: (obj, value) => { obj.imageOptions = value; } }, metadata: _metadata }, _imageOptions_initializers, _imageOptions_extraInitializers);
+            __esDecorate(null, null, _acceptedContentTypes_decorators, { kind: "field", name: "acceptedContentTypes", static: false, private: false, access: { has: obj => "acceptedContentTypes" in obj, get: obj => obj.acceptedContentTypes, set: (obj, value) => { obj.acceptedContentTypes = value; } }, metadata: _metadata }, _acceptedContentTypes_initializers, _acceptedContentTypes_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ClipboardPasteButton = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        onPress = __runInitializers(this, _onPress_initializers, void 0);
+        backgroundColor = (__runInitializers(this, _onPress_extraInitializers), __runInitializers(this, _backgroundColor_initializers, void 0));
+        foregroundColor = (__runInitializers(this, _backgroundColor_extraInitializers), __runInitializers(this, _foregroundColor_initializers, void 0));
+        cornerStyle = (__runInitializers(this, _foregroundColor_extraInitializers), __runInitializers(this, _cornerStyle_initializers, void 0));
+        displayMode = (__runInitializers(this, _cornerStyle_extraInitializers), __runInitializers(this, _displayMode_initializers, void 0));
+        imageOptions = (__runInitializers(this, _displayMode_extraInitializers), __runInitializers(this, _imageOptions_initializers, void 0));
+        acceptedContentTypes = (__runInitializers(this, _imageOptions_extraInitializers), __runInitializers(this, _acceptedContentTypes_initializers, void 0));
+        propNames = (__runInitializers(this, _acceptedContentTypes_extraInitializers), [
+            'onPress',
+            'backgroundColor',
+            'foregroundColor',
+            'cornerStyle',
+            'displayMode',
+            'imageOptions',
+            'acceptedContentTypes',
+        ]);
+        renderView(props) {
+            return renderClipboardPasteButton(props);
+        }
+    };
+    return ClipboardPasteButton = _classThis;
+})();
+export { ClipboardPasteButton };

package/build/core/clipboard-paste-button.d.ts

@@ -0,0 +1,29 @@
+import type { IAccessibilityProps, IAriaProps, IDescriptor, IResponderProps } from '@symbiote-native/components';
+import type { IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+import type { IAcceptedContentType, ICornerStyle, IDisplayMode, IGetImageOptions, IPasteEventPayload } from './types';
+export declare const CLIPBOARD_PASTE_BUTTON_MODULE_NAME = "ExpoClipboard";
+export type IClipboardPasteButtonProps = IAccessibilityProps & IAriaProps & IResponderProps & {
+    /** Called with the pasted text or image, inspect `type` to tell them apart */
+    onPress: (data: IPasteEventPayload) => void;
+    /** Leaving it out lets the color follow the system theme */
+    backgroundColor?: string | null;
+    /** @default 'white' */
+    foregroundColor?: string | null;
+    /** @default 'capsule' */
+    cornerStyle?: ICornerStyle | null;
+    /** @default 'iconAndLabel' */
+    displayMode?: IDisplayMode | null;
+    /** Needs a width and a height, or the button does not appear */
+    style?: IStyleProp<Omit<IViewStyle, 'backgroundColor' | 'borderRadius' | 'color'>>;
+    imageOptions?: IGetImageOptions | null;
+    /** Do not combine `plain-text` with `html`, all text would be treated as `html` */
+    acceptedContentTypes?: IAcceptedContentType[];
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: ISymbioteEvent) => void;
+};
+export declare function clipboardPasteButtonViewName(): string;
+export declare function ensureClipboardPasteButtonRegistered(): boolean;
+/** Reads the native paste event, `null` when its payload has neither a text nor an image shape */
+export declare function toPasteEventPayload(event: ISymbioteEvent): IPasteEventPayload | null;
+export declare function renderClipboardPasteButton(props: object): IDescriptor | null;

package/build/core/clipboard-paste-button.js

@@ -0,0 +1,50 @@
+import { Platform, requireNativeViewManager } from 'expo-modules-core';
+import { el } from '@symbiote-native/components';
+import { expoViewManagerName, tryRegisterNativeView, } from '@symbiote-native/engine';
+export const CLIPBOARD_PASTE_BUTTON_MODULE_NAME = 'ExpoClipboard';
+const PASTE_EVENT_PROP = 'onPastePressed';
+const PASTE_TYPE = { text: 'text', image: 'image' };
+export function clipboardPasteButtonViewName() {
+    return expoViewManagerName(CLIPBOARD_PASTE_BUTTON_MODULE_NAME);
+}
+// Registers the view config in React Native's registry, which the engine derives the view's events
+// and prop processors from. Called at render, not at import: a registration that only a barrel's
+// load-time side effect performs is dropped by Metro's `inlineRequires` in release
+export function ensureClipboardPasteButtonRegistered() {
+    if (!Platform.select({ ios: true, default: false }))
+        return false;
+    return tryRegisterNativeView(() => requireNativeViewManager(CLIPBOARD_PASTE_BUTTON_MODULE_NAME));
+}
+function isImageSize(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof Reflect.get(value, 'width') === 'number' &&
+        typeof Reflect.get(value, 'height') === 'number');
+}
+/** Reads the native paste event, `null` when its payload has neither a text nor an image shape */
+export function toPasteEventPayload(event) {
+    const { type, text, data, size } = event.nativeEvent;
+    if (type === PASTE_TYPE.text && typeof text === 'string')
+        return { type, text };
+    if (type === PASTE_TYPE.image &&
+        typeof data === 'string' &&
+        isImageSize(size)) {
+        return { type, data, size };
+    }
+    return null;
+}
+// `object`, not the props type: Vue and Angular hand over an untyped attribute bag
+export function renderClipboardPasteButton(props) {
+    if (!ensureClipboardPasteButtonRegistered())
+        return null;
+    const onPress = Reflect.get(props, 'onPress');
+    const viewProps = Object.fromEntries(Object.entries(props).filter(([key]) => key !== 'onPress'));
+    return el(clipboardPasteButtonViewName(), {
+        ...viewProps,
+        [PASTE_EVENT_PROP]: (event) => {
+            const payload = toPasteEventPayload(event);
+            if (payload && typeof onPress === 'function')
+                onPress(payload);
+        },
+    });
+}

package/build/core/clipboard.d.ts

@@ -79,6 +79,8 @@ export declare function hasImageAsync(): Promise<boolean>;
  * content types whenever the clipboard changes.
  */
 export declare function addClipboardListener(listener: (event: IClipboardEvent) => void): EventSubscription;
+/** Whether `ClipboardPasteButton` can render, needs iOS 16 or newer */
+export declare const isPasteButtonAvailable: boolean;
 /**
  * Removes the listener added by `addClipboardListener`.
  * @deprecated use `subscription.remove()` instead.

package/build/core/clipboard.js

@@ -1,4 +1,4 @@
-import { UnavailabilityError } from 'expo-modules-core';
+import { Platform, UnavailabilityError } from 'expo-modules-core';
 import { CLIPBOARD_CHANGED_EVENT_NAME, expoClipboard } from './native-module.js';
 // Matches the module name upstream's own Clipboard.ts passes to every UnavailabilityError.
 const NATIVE_MODULE_NAME = 'Clipboard';
@@ -133,6 +133,11 @@ export async function hasImageAsync() {
 export function addClipboardListener(listener) {
     return expoClipboard.addListener(CLIPBOARD_CHANGED_EVENT_NAME, listener);
 }
+/** Whether `ClipboardPasteButton` can render, needs iOS 16 or newer */
+export const isPasteButtonAvailable = Platform.select({
+    ios: expoClipboard.isPasteButtonAvailable ?? false,
+    default: false,
+});
 /**
  * Removes the listener added by `addClipboardListener`.
  * @deprecated use `subscription.remove()` instead.

package/build/core/index.d.ts

@@ -1,3 +1,4 @@
-export { getStringAsync, setStringAsync, hasStringAsync, getUrlAsync, setUrlAsync, hasUrlAsync, getImageAsync, setImageAsync, hasImageAsync, addClipboardListener, removeClipboardListener, } from './clipboard';
-export { ContentType, StringFormat, type IGetStringOptions, type ISetStringOptions, type IGetImageOptions, type IClipboardImage, type IClipboardEvent, } from './types';
+export { getStringAsync, setStringAsync, hasStringAsync, getUrlAsync, setUrlAsync, hasUrlAsync, getImageAsync, setImageAsync, hasImageAsync, addClipboardListener, removeClipboardListener, isPasteButtonAvailable, } from './clipboard';
+export { clipboardPasteButtonViewName, ensureClipboardPasteButtonRegistered, renderClipboardPasteButton, toPasteEventPayload, type IClipboardPasteButtonProps, } from './clipboard-paste-button';
+export { ContentType, StringFormat, type IGetStringOptions, type ISetStringOptions, type IGetImageOptions, type IClipboardImage, type IClipboardEvent, type IAcceptedContentType, type ICornerStyle, type IDisplayMode, type ITextPasteEvent, type IImagePasteEvent, type IPasteEventPayload, } from './types';
 export type { EventSubscription } from 'expo-modules-core';

package/build/core/index.js

@@ -1,2 +1,3 @@
-export { getStringAsync, setStringAsync, hasStringAsync, getUrlAsync, setUrlAsync, hasUrlAsync, getImageAsync, setImageAsync, hasImageAsync, addClipboardListener, removeClipboardListener, } from './clipboard.js';
+export { getStringAsync, setStringAsync, hasStringAsync, getUrlAsync, setUrlAsync, hasUrlAsync, getImageAsync, setImageAsync, hasImageAsync, addClipboardListener, removeClipboardListener, isPasteButtonAvailable, } from './clipboard.js';
+export { clipboardPasteButtonViewName, ensureClipboardPasteButtonRegistered, renderClipboardPasteButton, toPasteEventPayload, } from './clipboard-paste-button.js';
 export { ContentType, StringFormat, } from './types.js';

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

@@ -13,5 +13,6 @@ export type INativeClipboardModule = {
     getImageAsync?(options: IGetImageOptions): Promise<IClipboardImage | null>;
     setImageAsync?(base64Image: string): Promise<void>;
     hasImageAsync?(): Promise<boolean>;
+    isPasteButtonAvailable?: boolean;
 };
 export declare const expoClipboard: INativeClipboardModule;

package/build/core/types.d.ts

@@ -65,3 +65,14 @@ export type IClipboardEvent = {
      */
     contentTypes: ContentType[];
 };
+export type IAcceptedContentType = 'plain-text' | 'image' | 'url' | 'html';
+export type ICornerStyle = 'dynamic' | 'fixed' | 'capsule' | 'large' | 'medium' | 'small';
+export type IDisplayMode = 'iconAndLabel' | 'iconOnly' | 'labelOnly';
+export type ITextPasteEvent = {
+    text: string;
+    type: 'text';
+};
+export type IImagePasteEvent = {
+    type: 'image';
+} & IClipboardImage;
+export type IPasteEventPayload = ITextPasteEvent | IImagePasteEvent;

package/build/core/types.js

@@ -1,10 +1,7 @@
 // Ported from expo-clipboard's own Clipboard.types.ts. ContentType and StringFormat are enums —
 // kept unprefixed, matching this repo's convention for enums (see AuthenticationType /
 // SecurityLevel in @symbiote-native/local-auth); the plain option/result shapes get this repo's
-// `I`-prefix convention for exported types. `ClipboardPasteButton`'s own types
-// (PasteEventPayload, TextPasteEvent, ImagePasteEvent, AcceptedContentType, CornerStyleType,
-// DisplayModeType) are intentionally not ported — that native paste-button view is out of scope
-// for this pass (see the package README).
+// `I`-prefix convention for exported types
 /**
  * Type used to define what type of data is stored in the clipboard.
  */

package/build/react/clipboard-paste-button.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from 'react';
+import type { IClipboardPasteButtonProps } from '../core/clipboard-paste-button';
+/** React twin of `expo-clipboard`'s `ClipboardPasteButton` (`UIPasteControl`), iOS only */
+export declare function ClipboardPasteButton(props: IClipboardPasteButtonProps): ReactElement | null;

package/build/react/clipboard-paste-button.js

@@ -0,0 +1,7 @@
+import { descriptorToReact } from '@symbiote-native/react';
+import { renderClipboardPasteButton } from '../core/clipboard-paste-button.js';
+/** React twin of `expo-clipboard`'s `ClipboardPasteButton` (`UIPasteControl`), iOS only */
+export function ClipboardPasteButton(props) {
+    const descriptor = renderClipboardPasteButton(props);
+    return descriptor ? descriptorToReact(descriptor) : null;
+}

package/build/react/index.d.ts

@@ -1,2 +1,3 @@
 export { useClipboard } from './hooks/use-clipboard';
+export { ClipboardPasteButton } from './clipboard-paste-button';
 export * from '../core';

package/build/react/index.js

@@ -5,4 +5,5 @@
 // adapters/react/src/hooks (never `composables`, that's Vue's term) and the shape of
 // @symbiote-native/sensors' useAccelerometer.
 export { useClipboard } from './hooks/use-clipboard/index.js';
+export { ClipboardPasteButton } from './clipboard-paste-button.js';
 export * from '../core/index.js';

package/build/solid/clipboard-paste-button.d.ts

@@ -0,0 +1,3 @@
+import { descriptorToSolid } from '@symbiote-native/solid';
+import type { IClipboardPasteButtonProps } from '../core/clipboard-paste-button';
+export declare function ClipboardPasteButton(props: IClipboardPasteButtonProps): ReturnType<typeof descriptorToSolid> | null;

package/build/solid/clipboard-paste-button.js

@@ -0,0 +1,10 @@
+import { descriptorToSolid } from '@symbiote-native/solid';
+import { renderClipboardPasteButton } from '../core/clipboard-paste-button.js';
+// The platform decision is made once at mount: the descriptor bridge builds the node once and
+// only diffs prop values afterwards, so the descriptor's shape must not change
+export function ClipboardPasteButton(props) {
+    const initial = renderClipboardPasteButton({ ...props });
+    if (!initial)
+        return null;
+    return descriptorToSolid(() => renderClipboardPasteButton({ ...props }) ?? initial);
+}

package/build/solid/index.d.ts

@@ -1,2 +1,3 @@
 export { createClipboard } from './primitives/create-clipboard';
+export { ClipboardPasteButton } from './clipboard-paste-button';
 export * from '../core';

package/build/solid/index.js

@@ -5,4 +5,5 @@
 // `create*` (never `hooks/`/`use*`, that is React's term and Solid's word for consuming an
 // existing thing) — see adapters/solid/src/primitives for the same convention.
 export { createClipboard } from './primitives/create-clipboard.js';
+export { ClipboardPasteButton } from './clipboard-paste-button.js';
 export * from '../core/index.js';

package/build/svelte/clipboard-paste-button.svelte

@@ -0,0 +1,17 @@
+<script lang="ts">
+  // The native view name is mixed-case, which a literal tag would parse as a component reference,
+  // so the tag is dynamic
+  import { hostProps } from '@symbiote-native/svelte/native-view-bridge';
+  import { renderClipboardPasteButton } from '../core/clipboard-paste-button';
+  import type { IClipboardPasteButtonProps } from '../core/clipboard-paste-button';
+
+  const props: IClipboardPasteButtonProps = $props();
+  const descriptor = $derived(renderClipboardPasteButton({ ...props }));
+</script>
+
+{#if descriptor}
+  <svelte:element
+    this={descriptor.type}
+    {@attach hostProps(descriptor.props)}
+  />
+{/if}

package/build/svelte/clipboard-paste-button.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { IClipboardPasteButtonProps } from '../core/clipboard-paste-button';
+declare const ClipboardPasteButton: import("svelte").Component<IClipboardPasteButtonProps, {}, "">;
+type ClipboardPasteButton = ReturnType<typeof ClipboardPasteButton>;
+export default ClipboardPasteButton;

package/build/svelte/index.d.ts

@@ -1,2 +1,3 @@
 export { useClipboard } from './runes/use-clipboard.svelte';
+export { default as ClipboardPasteButton } from './clipboard-paste-button.svelte';
 export * from '../core';

package/build/svelte/index.js

@@ -4,4 +4,5 @@
 // `$effect` (runes/use-clipboard.svelte.ts), mirroring the lifecycle-bucket naming convention of
 // adapters/svelte/src/runes (never `hooks/`/`composables/`, those are React's and Vue's terms).
 export { useClipboard } from './runes/use-clipboard.svelte';
+export { default as ClipboardPasteButton } from './clipboard-paste-button.svelte';
 export * from '../core/index.js';

package/build/vue/clipboard-paste-button.d.ts

@@ -0,0 +1,3 @@
+import { type VNode } from '@vue/runtime-core';
+/** Vue twin of `expo-clipboard`'s `ClipboardPasteButton` (`UIPasteControl`), iOS only */
+export declare const ClipboardPasteButton: import("vue").DefineComponent<{}, () => VNode | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/build/vue/clipboard-paste-button.js

@@ -0,0 +1,15 @@
+import { defineComponent } from '@vue/runtime-core';
+import { descriptorToVue, normalizeVueAttrs } from '@symbiote-native/vue';
+import { renderClipboardPasteButton } from '../core/clipboard-paste-button.js';
+/** Vue twin of `expo-clipboard`'s `ClipboardPasteButton` (`UIPasteControl`), iOS only */
+export const ClipboardPasteButton = defineComponent({
+    name: 'ClipboardPasteButton',
+    // Every attribute is a native view prop, so none falls through onto a wrapper element
+    inheritAttrs: false,
+    setup(_props, { attrs }) {
+        return () => {
+            const descriptor = renderClipboardPasteButton(normalizeVueAttrs(attrs));
+            return descriptor ? descriptorToVue(descriptor) : null;
+        };
+    },
+});

package/build/vue/index.d.ts

@@ -1,2 +1,3 @@
 export { useClipboard } from './composables/use-clipboard';
+export { ClipboardPasteButton } from './clipboard-paste-button';
 export * from '../core';

package/build/vue/index.js

@@ -5,4 +5,5 @@
 // convention of adapters/vue/src/composables (never `hooks/`, that's React's term) and the
 // shape of @symbiote-native/sensors' useAccelerometer composable.
 export { useClipboard } from './composables/use-clipboard/index.js';
+export { ClipboardPasteButton } from './clipboard-paste-button.js';
 export * from '../core/index.js';