@symbiote-native/sms 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,138 @@
+# @symbiote-native/sms
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-sms`](https://github.com/expo/expo/tree/main/packages/expo-sms) — opening the system SMS
+composer prefilled with recipients, a message, and optionally an attachment — 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).
+
+Nothing is ever sent on the user's behalf. Both platforms open their own composer with the draft
+filled in; the user presses send, edits, or discards it.
+
+## Install
+
+```bash
+npm install @symbiote-native/sms
+```
+
+`expo-sms` 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-sms`'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.
+
+### No permissions, no manifest edits, no config plugin
+
+This is the least invasive of the Expo wrappers here:
+
+- **No runtime permission on either platform.** Opening the composer is an intent
+  (`ACTION_SENDTO`/`ACTION_SEND`) on Android and an `MFMessageComposeViewController` on iOS —
+  the user's own app does the sending, so neither platform asks for one. `expo-sms` requests no
+  permission anywhere in its native code, and reading the *outcome* of a sent message on Android
+  would need `READ_SMS`, which is exactly why it doesn't try (see the `unknown` result below).
+- **No `Info.plist` usage-description key.**
+- **No manifest edit.** `expo-sms` ships its own `<queries>` block declaring the `SEND`/`SENDTO`
+  intents it resolves, needed on Android 11+ package-visibility rules; it merges into your app
+  automatically once the Gradle project is included.
+- **No config plugin.** Upstream ships none at all, so there is nothing else to apply.
+
+## Shape
+
+```
+src/core/                 the whole API: sendSMSAsync + isAvailableAsync. native-module.ts
+                          resolves ExpoSMS through expo-modules-core's requireNativeModule.
+src/react/                @symbiote-native/sms/react
+src/vue/                  @symbiote-native/sms/vue
+src/angular/              @symbiote-native/sms/angular
+```
+
+All three adapter entries are plain re-exports of `core/`. Both exports are stateless free
+functions — `sendSMSAsync` resolves once the composer closes and holds nothing afterwards, and
+there is 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.
+Import from `@symbiote-native/sms` 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, sendSMSAsync } from '@symbiote-native/sms';
+
+if (await isAvailableAsync()) {
+  const { result } = await sendSMSAsync(['0123456789', '9876543210'], 'Running late, sorry!');
+  // 'sent' | 'cancelled' on iOS; always 'unknown' on Android
+}
+```
+
+A single recipient may be passed as a bare string — it is normalised into an array before the
+native call:
+
+```ts
+await sendSMSAsync('0123456789', 'Running late, sorry!');
+```
+
+With an attachment:
+
+```ts
+await sendSMSAsync('0123456789', 'Here is the receipt', {
+  attachments: {
+    uri: 'content://media/external/images/media/1',
+    mimeType: 'image/png',
+    filename: 'receipt.png',
+  },
+});
+```
+
+The `uri` has to be a **content** URI — the composer runs in another app's process, and a plain
+file path is not readable from there.
+
+## API
+
+| Export | Signature | Notes |
+|---|---|---|
+| `isAvailableAsync` | `() => Promise<boolean>` | `false` on the iOS simulator, which has no Messages app, and on Android devices without telephony hardware. |
+| `sendSMSAsync` | `(addresses, message, options?) => Promise<ISmsResponse>` | Opens the composer. Resolves when it closes. Throws if the device has no messaging app. |
+
+`ISmsOptions`: `attachments` — one `ISmsAttachment` or a list of them.
+`ISmsAttachment`: `uri` (content URI), `mimeType`, `filename`.
+`ISmsResponse`: `{ result: 'sent' | 'cancelled' | 'unknown' }`.
+
+## Notes
+
+- **Android always resolves `unknown`.** The only way to learn whether a message actually left
+  the device is to query the SMS database, which needs the `READ_SMS` permission Google restricts
+  to default-SMS-app publishers. Treat `unknown` as "the composer closed", not as a failure.
+- **Android carries one attachment.** Its composer intent has a single `EXTRA_STREAM` slot, so
+  anything past the first is dropped before the native call rather than silently ignored deeper
+  down. iOS attaches all of them.
+- **`sendSMSAsync` can reject.** Android throws when no messaging application is installed; iOS
+  throws when the device cannot send text at all, or when a composer is already open.
+
+## Test it
+
+```bash
+pnpm vitest run packages/sms
+```
+
+The core tests fake the native module in place of `requireNativeModule`'s runtime resolution —
+`ExpoSMS` only exists on a device, so a headless run would otherwise throw at import. The
+composer itself, and the `sent`/`cancelled` distinction, can only be verified on a device.

package/build/angular/index.d.ts

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

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/sms/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state and no event stream to wrap in an
+// injectable service, so this is a plain re-export.
+export * from '../core';

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { isAvailableAsync, sendSMSAsync } from './sms';
+export type { ISmsAttachment, ISmsOptions, ISmsResponse, ISmsResultStatus } from './types';

package/build/core/index.js

@@ -0,0 +1 @@
+export { isAvailableAsync, sendSMSAsync } from './sms';

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

@@ -0,0 +1,14 @@
+import type { ISmsAttachment, ISmsResponse } from './types';
+/**
+ * The options record the native side decodes — narrower than the public `ISmsOptions`, which
+ * also accepts a lone attachment object. Both `SMSOptions.kt` and `SMSOptions.swift` declare
+ * `attachments` as a list, so the single-object form is normalised away before it gets here.
+ */
+export type INativeSmsOptions = {
+    attachments?: ISmsAttachment[];
+};
+export type INativeSmsModule = {
+    isAvailableAsync?(): Promise<boolean>;
+    sendSMSAsync?(addresses: string[], message: string, options: INativeSmsOptions): Promise<ISmsResponse>;
+};
+export declare const expoSms: INativeSmsModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_SMS_MODULE_NAME = 'ExpoSMS';
+export const expoSms = requireNativeModule(EXPO_SMS_MODULE_NAME);

package/build/core/sms.d.ts

@@ -0,0 +1,19 @@
+import type { ISmsOptions, ISmsResponse } from './types';
+/**
+ * Whether this device can send an SMS at all. `false` on the iOS simulator, which has no
+ * Messages app, and on any Android device without telephony hardware.
+ */
+export declare function isAvailableAsync(): Promise<boolean>;
+/**
+ * Opens the system SMS composer with the recipients and message text filled in. Nothing is sent
+ * on the user's behalf — they still press send themselves, and may edit or discard the draft.
+ *
+ * Resolves once the composer closes:
+ * - `{ result: 'sent' }` — the user sent or scheduled the message.
+ * - `{ result: 'cancelled' }` — the user dismissed the composer.
+ * - `{ result: 'unknown' }` — always, on Android, which cannot report the outcome.
+ *
+ * The only thing observed is whether a message left the composer; neither its final text nor
+ * its final recipients are read back.
+ */
+export declare function sendSMSAsync(addresses: string | string[], message: string, options?: ISmsOptions): Promise<ISmsResponse>;

package/build/core/sms.js

@@ -0,0 +1,47 @@
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { expoSms } from './native-module';
+const NATIVE_MODULE_NAME = 'expo-sms';
+// Android's SMSModule puts a single `Intent.EXTRA_STREAM` on the composer intent and reads
+// `attachments[0]` to fill it, so anything past the first would silently never arrive.
+const ANDROID_ATTACHMENT_LIMIT = 1;
+/**
+ * Whether this device can send an SMS at all. `false` on the iOS simulator, which has no
+ * Messages app, and on any Android device without telephony hardware.
+ */
+export async function isAvailableAsync() {
+    return expoSms.isAvailableAsync?.() ?? false;
+}
+/**
+ * Opens the system SMS composer with the recipients and message text filled in. Nothing is sent
+ * on the user's behalf — they still press send themselves, and may edit or discard the draft.
+ *
+ * Resolves once the composer closes:
+ * - `{ result: 'sent' }` — the user sent or scheduled the message.
+ * - `{ result: 'cancelled' }` — the user dismissed the composer.
+ * - `{ result: 'unknown' }` — always, on Android, which cannot report the outcome.
+ *
+ * The only thing observed is whether a message left the composer; neither its final text nor
+ * its final recipients are read back.
+ */
+export async function sendSMSAsync(addresses, message, options) {
+    if (!expoSms.sendSMSAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'sendSMSAsync');
+    }
+    const recipients = Array.isArray(addresses) ? addresses : [addresses];
+    for (const recipient of recipients) {
+        // Guards a caller without type checking: the native side decodes a list of strings, and a
+        // number or a null in there fails as an opaque conversion error far from its cause.
+        if (typeof recipient !== 'string') {
+            throw new TypeError('Invalid address passed to sendSMSAsync. Every recipient must be a string.');
+        }
+    }
+    const nativeOptions = {};
+    if (options?.attachments) {
+        nativeOptions.attachments = normalizeAttachments(options.attachments);
+    }
+    return expoSms.sendSMSAsync(recipients, message, nativeOptions);
+}
+function normalizeAttachments(attachments) {
+    const list = Array.isArray(attachments) ? attachments : [attachments];
+    return Platform.OS === 'android' ? list.slice(0, ANDROID_ATTACHMENT_LIMIT) : list;
+}

package/build/core/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * How the composer was dismissed.
+ *
+ * Android never reports it: reading the outcome would mean querying the device's SMS database,
+ * which needs the `READ_SMS` permission Google restricts to default-SMS-app publishers, so the
+ * native module resolves `unknown` unconditionally there.
+ */
+export type ISmsResultStatus = 'unknown' | 'sent' | 'cancelled';
+export type ISmsResponse = {
+    /** Status of the SMS action the user invoked. */
+    result: ISmsResultStatus;
+};
+/** A file to attach to the drafted message. */
+export type ISmsAttachment = {
+    /**
+     * Content URI of the file. It has to be a content URI so applications outside your own can
+     * read it — a plain file path is not reachable from the system composer.
+     */
+    uri: string;
+    /** MIME type of the attachment, such as `image/png`. */
+    mimeType: string;
+    /** File name shown for the attachment in the composer. */
+    filename: string;
+};
+export type ISmsOptions = {
+    /**
+     * One attachment or a list of them. Android carries only the first — its composer intent has
+     * a single `EXTRA_STREAM` slot — so anything past it is dropped before the native call.
+     */
+    attachments?: ISmsAttachment | ISmsAttachment[];
+};

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/sms/react: the React entry over the framework-agnostic core.
+// Both exports are stateless free functions — `sendSMSAsync` resolves once the system composer
+// closes and holds nothing afterwards, and there is no event stream to subscribe to — so there
+// is nothing for a hook to own or clean up. Plain re-export, the same shape
+// packages/secure-store's React entry has for the same reason.
+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/sms/vue: the Vue entry over the framework-agnostic core. Same reasoning as
+// the React entry — no per-instance state and no 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/sms/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state and no event stream to wrap in an
+// injectable 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,yFAAyF;AACzF,+FAA+F;AAC/F,oDAAoD;AACpD,cAAc,SAAS,CAAC"}

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

@@ -0,0 +1,2 @@
+export { isAvailableAsync, sendSMSAsync } from './sms';
+export type { ISmsAttachment, ISmsOptions, ISmsResponse, ISmsResultStatus } from './types';

package/build-ngc/core/index.js

@@ -0,0 +1,2 @@
+export { isAvailableAsync, sendSMSAsync } from './sms';
+//# 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,YAAY,EAAE,MAAM,OAAO,CAAC"}

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

@@ -0,0 +1,14 @@
+import type { ISmsAttachment, ISmsResponse } from './types';
+/**
+ * The options record the native side decodes — narrower than the public `ISmsOptions`, which
+ * also accepts a lone attachment object. Both `SMSOptions.kt` and `SMSOptions.swift` declare
+ * `attachments` as a list, so the single-object form is normalised away before it gets here.
+ */
+export type INativeSmsOptions = {
+    attachments?: ISmsAttachment[];
+};
+export type INativeSmsModule = {
+    isAvailableAsync?(): Promise<boolean>;
+    sendSMSAsync?(addresses: string[], message: string, options: INativeSmsOptions): Promise<ISmsResponse>;
+};
+export declare const expoSms: INativeSmsModule;

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

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_SMS_MODULE_NAME = 'ExpoSMS';
+export const expoSms = requireNativeModule(EXPO_SMS_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,oBAAoB,GAAG,SAAS,CAAC;AAuBvC,MAAM,CAAC,MAAM,OAAO,GAAG,mBAAmB,CAAmB,oBAAoB,CAAC,CAAC"}

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

@@ -0,0 +1,19 @@
+import type { ISmsOptions, ISmsResponse } from './types';
+/**
+ * Whether this device can send an SMS at all. `false` on the iOS simulator, which has no
+ * Messages app, and on any Android device without telephony hardware.
+ */
+export declare function isAvailableAsync(): Promise<boolean>;
+/**
+ * Opens the system SMS composer with the recipients and message text filled in. Nothing is sent
+ * on the user's behalf — they still press send themselves, and may edit or discard the draft.
+ *
+ * Resolves once the composer closes:
+ * - `{ result: 'sent' }` — the user sent or scheduled the message.
+ * - `{ result: 'cancelled' }` — the user dismissed the composer.
+ * - `{ result: 'unknown' }` — always, on Android, which cannot report the outcome.
+ *
+ * The only thing observed is whether a message left the composer; neither its final text nor
+ * its final recipients are read back.
+ */
+export declare function sendSMSAsync(addresses: string | string[], message: string, options?: ISmsOptions): Promise<ISmsResponse>;

package/build-ngc/core/sms.js

@@ -0,0 +1,48 @@
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { expoSms } from './native-module';
+const NATIVE_MODULE_NAME = 'expo-sms';
+// Android's SMSModule puts a single `Intent.EXTRA_STREAM` on the composer intent and reads
+// `attachments[0]` to fill it, so anything past the first would silently never arrive.
+const ANDROID_ATTACHMENT_LIMIT = 1;
+/**
+ * Whether this device can send an SMS at all. `false` on the iOS simulator, which has no
+ * Messages app, and on any Android device without telephony hardware.
+ */
+export async function isAvailableAsync() {
+    return expoSms.isAvailableAsync?.() ?? false;
+}
+/**
+ * Opens the system SMS composer with the recipients and message text filled in. Nothing is sent
+ * on the user's behalf — they still press send themselves, and may edit or discard the draft.
+ *
+ * Resolves once the composer closes:
+ * - `{ result: 'sent' }` — the user sent or scheduled the message.
+ * - `{ result: 'cancelled' }` — the user dismissed the composer.
+ * - `{ result: 'unknown' }` — always, on Android, which cannot report the outcome.
+ *
+ * The only thing observed is whether a message left the composer; neither its final text nor
+ * its final recipients are read back.
+ */
+export async function sendSMSAsync(addresses, message, options) {
+    if (!expoSms.sendSMSAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'sendSMSAsync');
+    }
+    const recipients = Array.isArray(addresses) ? addresses : [addresses];
+    for (const recipient of recipients) {
+        // Guards a caller without type checking: the native side decodes a list of strings, and a
+        // number or a null in there fails as an opaque conversion error far from its cause.
+        if (typeof recipient !== 'string') {
+            throw new TypeError('Invalid address passed to sendSMSAsync. Every recipient must be a string.');
+        }
+    }
+    const nativeOptions = {};
+    if (options?.attachments) {
+        nativeOptions.attachments = normalizeAttachments(options.attachments);
+    }
+    return expoSms.sendSMSAsync(recipients, message, nativeOptions);
+}
+function normalizeAttachments(attachments) {
+    const list = Array.isArray(attachments) ? attachments : [attachments];
+    return Platform.OS === 'android' ? list.slice(0, ANDROID_ATTACHMENT_LIMIT) : list;
+}
+//# sourceMappingURL=sms.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sms.js","sourceRoot":"","sources":["../../src/core/sms.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,EAAE,OAAO,EAA0B,MAAM,iBAAiB,CAAC;AAGlE,MAAM,kBAAkB,GAAG,UAAU,CAAC;AAEtC,2FAA2F;AAC3F,uFAAuF;AACvF,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAEnC;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,OAAO,OAAO,CAAC,gBAAgB,EAAE,EAAE,IAAI,KAAK,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,SAA4B,EAC5B,OAAe,EACf,OAAqB;IAErB,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;QAC1B,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,cAAc,CAAC,CAAC;IACpE,CAAC;IAED,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACtE,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,0FAA0F;QAC1F,oFAAoF;QACpF,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;YAClC,MAAM,IAAI,SAAS,CACjB,2EAA2E,CAC5E,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,aAAa,GAAsB,EAAE,CAAC;IAC5C,IAAI,OAAO,EAAE,WAAW,EAAE,CAAC;QACzB,aAAa,CAAC,WAAW,GAAG,oBAAoB,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IACxE,CAAC;IAED,OAAO,OAAO,CAAC,YAAY,CAAC,UAAU,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;AAClE,CAAC;AAED,SAAS,oBAAoB,CAAC,WAA8C;IAC1E,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACtE,OAAO,QAAQ,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,wBAAwB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACpF,CAAC"}

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

@@ -0,0 +1,31 @@
+/**
+ * How the composer was dismissed.
+ *
+ * Android never reports it: reading the outcome would mean querying the device's SMS database,
+ * which needs the `READ_SMS` permission Google restricts to default-SMS-app publishers, so the
+ * native module resolves `unknown` unconditionally there.
+ */
+export type ISmsResultStatus = 'unknown' | 'sent' | 'cancelled';
+export type ISmsResponse = {
+    /** Status of the SMS action the user invoked. */
+    result: ISmsResultStatus;
+};
+/** A file to attach to the drafted message. */
+export type ISmsAttachment = {
+    /**
+     * Content URI of the file. It has to be a content URI so applications outside your own can
+     * read it — a plain file path is not reachable from the system composer.
+     */
+    uri: string;
+    /** MIME type of the attachment, such as `image/png`. */
+    mimeType: string;
+    /** File name shown for the attachment in the composer. */
+    filename: string;
+};
+export type ISmsOptions = {
+    /**
+     * One attachment or a list of them. Android carries only the first — its composer intent has
+     * a single `EXTRA_STREAM` slot — so anything past it is dropped before the native call.
+     */
+    attachments?: ISmsAttachment | ISmsAttachment[];
+};

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-sms",
+    "modules": [
+      {
+        "importPath": "expo.modules.sms.SMSModule",
+        "className": "SMSModule",
+        "nativeName": "ExpoSMS"
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@symbiote-native/sms",
+  "version": "0.0.1",
+  "description": "expo-sms wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Opens the system SMS composer prefilled with recipients and a message.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/sms"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/sms#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-sms": "57.0.1",
+    "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/engine": "0.1.7",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "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/sms/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state and no event stream to wrap in an
+// injectable service, so this is a plain re-export.
+export * from '../core';

package/src/core/index.ts

@@ -0,0 +1,2 @@
+export { isAvailableAsync, sendSMSAsync } from './sms';
+export type { ISmsAttachment, ISmsOptions, ISmsResponse, ISmsResultStatus } from './types';

package/src/core/native-module.ts

@@ -0,0 +1,27 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { ISmsAttachment, ISmsResponse } from './types';
+
+const EXPO_SMS_MODULE_NAME = 'ExpoSMS';
+
+/**
+ * The options record the native side decodes — narrower than the public `ISmsOptions`, which
+ * also accepts a lone attachment object. Both `SMSOptions.kt` and `SMSOptions.swift` declare
+ * `attachments` as a list, so the single-object form is normalised away before it gets here.
+ */
+export type INativeSmsOptions = {
+  attachments?: ISmsAttachment[];
+};
+
+// Both members are optional: each call site checks for its own before calling through, the same
+// per-platform capability check upstream makes, rather than assuming the native module
+// implements the whole surface.
+export type INativeSmsModule = {
+  isAvailableAsync?(): Promise<boolean>;
+  sendSMSAsync?(
+    addresses: string[],
+    message: string,
+    options: INativeSmsOptions,
+  ): Promise<ISmsResponse>;
+};
+
+export const expoSms = requireNativeModule<INativeSmsModule>(EXPO_SMS_MODULE_NAME);

package/src/core/sms.test.ts

@@ -0,0 +1,141 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_SMS = {
+  isAvailableAsync: vi.fn(async () => true),
+  sendSMSAsync: vi.fn(async () => ({ result: 'sent' })),
+};
+
+// Mutated per test — `Platform.OS` is read at call time, so flipping this between cases is how
+// the Android attachment limit gets exercised without a second import of the module under test.
+const FAKE_PLATFORM = { OS: 'ios' };
+
+// The real ExpoSMS 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', () => ({
+  expoSms: FAKE_NATIVE_SMS,
+}));
+
+// 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', () => ({
+  Platform: FAKE_PLATFORM,
+  UnavailabilityError: class UnavailabilityError extends Error {
+    constructor(moduleName: string, propertyName: string) {
+      super(`${propertyName} is not available on ${moduleName}`);
+    }
+  },
+}));
+
+const { isAvailableAsync, sendSMSAsync } = await import('./sms');
+
+const IMAGE_ATTACHMENT = {
+  uri: 'content://media/external/images/media/1',
+  mimeType: 'image/png',
+  filename: 'myfile.png',
+};
+const AUDIO_ATTACHMENT = {
+  uri: 'content://media/external/audio/media/2',
+  mimeType: 'audio/mpeg',
+  filename: 'myfile.mp3',
+};
+
+beforeEach(() => {
+  FAKE_PLATFORM.OS = 'ios';
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('isAvailableAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(isAvailableAsync()).resolves.toBe(true);
+    expect(FAKE_NATIVE_SMS.isAvailableAsync).toHaveBeenCalledTimes(1);
+  });
+
+  it('reports unavailable rather than throwing when the native method is absent', async () => {
+    const { isAvailableAsync: native } = FAKE_NATIVE_SMS;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_SMS.isAvailableAsync = undefined;
+
+    await expect(isAvailableAsync()).resolves.toBe(false);
+
+    FAKE_NATIVE_SMS.isAvailableAsync = native;
+  });
+});
+
+describe('sendSMSAsync recipients', () => {
+  it('normalizes a single address into an array', async () => {
+    await sendSMSAsync('0123456789', 'test');
+    expect(FAKE_NATIVE_SMS.sendSMSAsync).toHaveBeenLastCalledWith(['0123456789'], 'test', {});
+  });
+
+  it('passes an array of addresses through unchanged', async () => {
+    await sendSMSAsync(['0123456789', '9876543210'], 'test');
+    expect(FAKE_NATIVE_SMS.sendSMSAsync).toHaveBeenLastCalledWith(
+      ['0123456789', '9876543210'],
+      'test',
+      {},
+    );
+  });
+
+  it('resolves with the native result', async () => {
+    await expect(sendSMSAsync('0123456789', 'test')).resolves.toEqual({ result: 'sent' });
+  });
+
+  it('rejects a non-string recipient before reaching the native module', async () => {
+    // @ts-expect-error -- the guard exists precisely for callers without type checking
+    await expect(sendSMSAsync(['0123456789', null], 'test')).rejects.toThrow(TypeError);
+    expect(FAKE_NATIVE_SMS.sendSMSAsync).not.toHaveBeenCalled();
+  });
+});
+
+describe('sendSMSAsync attachments', () => {
+  it('omits the attachments key entirely when none are given', async () => {
+    await sendSMSAsync('0123456789', 'test', {});
+    expect(FAKE_NATIVE_SMS.sendSMSAsync).toHaveBeenLastCalledWith(['0123456789'], 'test', {});
+  });
+
+  it('normalizes a single attachment into an array', async () => {
+    await sendSMSAsync('0123456789', 'test', { attachments: IMAGE_ATTACHMENT });
+    expect(FAKE_NATIVE_SMS.sendSMSAsync).toHaveBeenLastCalledWith(['0123456789'], 'test', {
+      attachments: [IMAGE_ATTACHMENT],
+    });
+  });
+
+  it('keeps every attachment on iOS', async () => {
+    await sendSMSAsync('0123456789', 'test', {
+      attachments: [IMAGE_ATTACHMENT, AUDIO_ATTACHMENT],
+    });
+    expect(FAKE_NATIVE_SMS.sendSMSAsync).toHaveBeenLastCalledWith(['0123456789'], 'test', {
+      attachments: [IMAGE_ATTACHMENT, AUDIO_ATTACHMENT],
+    });
+  });
+
+  it('keeps only the first attachment on Android', async () => {
+    FAKE_PLATFORM.OS = 'android';
+
+    await sendSMSAsync('0123456789', 'test', {
+      attachments: [IMAGE_ATTACHMENT, AUDIO_ATTACHMENT],
+    });
+    expect(FAKE_NATIVE_SMS.sendSMSAsync).toHaveBeenLastCalledWith(['0123456789'], 'test', {
+      attachments: [IMAGE_ATTACHMENT],
+    });
+  });
+});
+
+describe('sendSMSAsync without the native method', () => {
+  it('throws an UnavailabilityError-shaped error', async () => {
+    const { sendSMSAsync: native } = FAKE_NATIVE_SMS;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_SMS.sendSMSAsync = undefined;
+
+    await expect(sendSMSAsync('0123456789', 'test')).rejects.toThrow(
+      'sendSMSAsync is not available on expo-sms',
+    );
+
+    FAKE_NATIVE_SMS.sendSMSAsync = native;
+  });
+});

package/src/core/sms.ts

@@ -0,0 +1,63 @@
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+
+import { expoSms, type INativeSmsOptions } from './native-module';
+import type { ISmsAttachment, ISmsOptions, ISmsResponse } from './types';
+
+const NATIVE_MODULE_NAME = 'expo-sms';
+
+// Android's SMSModule puts a single `Intent.EXTRA_STREAM` on the composer intent and reads
+// `attachments[0]` to fill it, so anything past the first would silently never arrive.
+const ANDROID_ATTACHMENT_LIMIT = 1;
+
+/**
+ * Whether this device can send an SMS at all. `false` on the iOS simulator, which has no
+ * Messages app, and on any Android device without telephony hardware.
+ */
+export async function isAvailableAsync(): Promise<boolean> {
+  return expoSms.isAvailableAsync?.() ?? false;
+}
+
+/**
+ * Opens the system SMS composer with the recipients and message text filled in. Nothing is sent
+ * on the user's behalf — they still press send themselves, and may edit or discard the draft.
+ *
+ * Resolves once the composer closes:
+ * - `{ result: 'sent' }` — the user sent or scheduled the message.
+ * - `{ result: 'cancelled' }` — the user dismissed the composer.
+ * - `{ result: 'unknown' }` — always, on Android, which cannot report the outcome.
+ *
+ * The only thing observed is whether a message left the composer; neither its final text nor
+ * its final recipients are read back.
+ */
+export async function sendSMSAsync(
+  addresses: string | string[],
+  message: string,
+  options?: ISmsOptions,
+): Promise<ISmsResponse> {
+  if (!expoSms.sendSMSAsync) {
+    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'sendSMSAsync');
+  }
+
+  const recipients = Array.isArray(addresses) ? addresses : [addresses];
+  for (const recipient of recipients) {
+    // Guards a caller without type checking: the native side decodes a list of strings, and a
+    // number or a null in there fails as an opaque conversion error far from its cause.
+    if (typeof recipient !== 'string') {
+      throw new TypeError(
+        'Invalid address passed to sendSMSAsync. Every recipient must be a string.',
+      );
+    }
+  }
+
+  const nativeOptions: INativeSmsOptions = {};
+  if (options?.attachments) {
+    nativeOptions.attachments = normalizeAttachments(options.attachments);
+  }
+
+  return expoSms.sendSMSAsync(recipients, message, nativeOptions);
+}
+
+function normalizeAttachments(attachments: ISmsAttachment | ISmsAttachment[]): ISmsAttachment[] {
+  const list = Array.isArray(attachments) ? attachments : [attachments];
+  return Platform.OS === 'android' ? list.slice(0, ANDROID_ATTACHMENT_LIMIT) : list;
+}

package/src/core/types.ts

@@ -0,0 +1,34 @@
+/**
+ * How the composer was dismissed.
+ *
+ * Android never reports it: reading the outcome would mean querying the device's SMS database,
+ * which needs the `READ_SMS` permission Google restricts to default-SMS-app publishers, so the
+ * native module resolves `unknown` unconditionally there.
+ */
+export type ISmsResultStatus = 'unknown' | 'sent' | 'cancelled';
+
+export type ISmsResponse = {
+  /** Status of the SMS action the user invoked. */
+  result: ISmsResultStatus;
+};
+
+/** A file to attach to the drafted message. */
+export type ISmsAttachment = {
+  /**
+   * Content URI of the file. It has to be a content URI so applications outside your own can
+   * read it — a plain file path is not reachable from the system composer.
+   */
+  uri: string;
+  /** MIME type of the attachment, such as `image/png`. */
+  mimeType: string;
+  /** File name shown for the attachment in the composer. */
+  filename: string;
+};
+
+export type ISmsOptions = {
+  /**
+   * One attachment or a list of them. Android carries only the first — its composer intent has
+   * a single `EXTRA_STREAM` slot — so anything past it is dropped before the native call.
+   */
+  attachments?: ISmsAttachment | ISmsAttachment[];
+};

package/src/react/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/sms/react: the React entry over the framework-agnostic core.
+// Both exports are stateless free functions — `sendSMSAsync` resolves once the system composer
+// closes and holds nothing afterwards, and there is no event stream to subscribe to — so there
+// is nothing for a hook to own or clean up. Plain re-export, the same shape
+// packages/secure-store's React entry has for the same reason.
+export * from '../core';

package/src/vue/index.ts

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