@webority/mobile-support 0.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Webority Technologies
+
+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,146 @@
+# @webority/mobile-support
+
+Customer support tickets for Webority React Native apps. It talks to the Webority Support
+endpoints a product hosts (`MapWeboritySupportEndpoints("/api/support")`) and gives the app
+ready screens: the ticket list, a ticket's thread, a new ticket form, a contact card and a
+report-an-issue button that attaches a screenshot of the current screen.
+
+```bash
+npm install @webority/mobile-support
+```
+
+Builds on `@webority/mobile-core` (the HTTP client, device context, image
+compression) and `@webority/mobile-ui` (theme, components, form engine).
+
+## Peers
+
+| Package | Why | Required |
+|---|---|---|
+| `expo-image-picker` | photos from the library and the camera | yes |
+| `expo-image-manipulator`, `expo-file-system` | photos are bounded and compressed before upload (mobile-core's compressor); attachments are saved to the cache before opening | yes |
+| `expo-clipboard` | copy the support email | yes |
+| `react-native-gesture-handler` | pinch to zoom in the full-screen image view | yes (mobile-ui needs it too) |
+| `react-native-view-shot` | the screen capture behind `ReportIssueButton` | only if you import `/report` |
+| `expo-sharing` | opens a PDF or text attachment through the share sheet | only if you import `/share` |
+
+`react-native-view-shot` is named only under the `/report` import path and `expo-sharing` only
+under `/share`, so an app that never imports them does not need the packages installed.
+
+## Wire it up
+
+Create the client over the app's own signed-in HTTP client, so every support call carries the
+same bearer token, tenant header and refresh handling as the rest of the app. Pass the prefix the
+product mapped the endpoints on.
+
+```tsx
+import { userClient } from '@webority/mobile-core';
+import { createSupportClient, SupportProvider } from '@webority/mobile-support';
+
+const supportClient = createSupportClient(userClient, '/api/support');
+
+export const App = () => (
+  <ThemeProvider>
+    <SupportProvider client={supportClient}>
+      <Navigation />
+    </SupportProvider>
+  </ThemeProvider>
+);
+```
+
+## Screens
+
+The screens know nothing about navigation. Place them in your own navigator and pass callbacks.
+
+```tsx
+import {
+  NewSupportTicket,
+  SupportContact,
+  SupportTicketDetail,
+  SupportTicketList
+} from '@webority/mobile-support';
+
+const SupportScreen = ({ navigation }) => (
+  <SupportTicketList
+    header={<SupportContact />}
+    onOpenTicket={(t) => navigation.navigate('SupportTicket', { id: t.id })}
+    onNewTicket={() => navigation.navigate('NewSupportTicket')}
+  />
+);
+
+const SupportTicketScreen = ({ route }) => <SupportTicketDetail ticketId={route.params.id} />;
+
+const NewSupportTicketScreen = ({ navigation, route }) => (
+  <NewSupportTicket
+    initialDraft={route.params?.draft}
+    onCancel={() => navigation.goBack()}
+    onCreated={(t) => navigation.replace('SupportTicket', { id: t.id })}
+  />
+);
+```
+
+- **SupportTicketList**: one page at a time (`pageSize`, default 20), the next page loading as
+  the person reaches the end. Status chips carry the counts from `GET /tickets/counts`; a chip and
+  the search box (subject or ticket number) filter on the server and start again from page 1, as
+  does pull to refresh. Empty state, retry on failure, and a Load more retry when a later page
+  fails without losing the rows already shown.
+- **SupportTicketDetail**: the thread as bubbles, status events as small centred lines, image
+  thumbnails that open full screen, a reply box with photos, Reopen when `canReopen`, and a
+  satisfied or not satisfied rating with an optional comment when `canRate`. Replying to a
+  resolved or closed ticket reopens it.
+- **NewSupportTicket**: category, subject, message and photos, checked against the limits the
+  product sends in `GET /settings` before anything is uploaded.
+- **SupportContact**: the support email with copy and compose, the phone number, and the hours.
+
+## Report an issue
+
+```tsx
+import { ReportIssueButton } from '@webority/mobile-support/report';
+
+<ReportIssueButton
+  screenName={route.name}
+  appVersion={AppSettings.VERSION_DISPLAY}
+  onReport={(draft) => navigation.navigate('NewSupportTicket', { draft })}
+/>;
+```
+
+The button captures the screen, then hands your app a draft with the image under
+`screenshots`, the screen name as the page, the device line and the app version.
+`captureAndReport(options)` does the same without the button. The device line reads the
+platform and OS version, plus the model when the app has called mobile-core's
+`setDeviceContext`.
+
+## Hooks
+
+`useSupportConfig()`, `useSupportTickets({ pageSize })`, `useSupportTicket(id)` and
+`useCreateSupportTicket()` expose the same data for apps that build their own screens.
+`useSupportTickets` returns the pages loaded so far as `tickets`, the `counts`, `status` and
+`search` with their setters, `loadMore` and `hasMore`, and `refresh`. Every
+failure is a `SupportApiError` whose `message` is written for the person and can be shown as is;
+branch on `code`, never show it.
+
+`client.confirmAction(token)` sends the person's yes to a support action an assistant prepared
+(raise a ticket, reply on one, reopen one) as `POST {base}/actions/confirm`. Only this call
+completes the action. It resolves to the ticket it acted on; an expired or unknown token rejects
+with the code `action_expired`.
+
+## Attachments
+
+Attachment files need the bearer token, so thumbnails are fetched through the client you passed
+in and shown from a `data:` URI, cached for the session.
+
+Files that are not images (a PDF, a text file) show their name and size. To let people open
+them, give `SupportProvider` an `openFile`. The file is downloaded through the same client, saved
+to the app's cache, then handed to your opener. `/share` ships one that uses the system share
+sheet (install `expo-sharing`):
+
+```tsx
+import { shareSupportFile } from '@webority/mobile-support/share';
+
+<SupportProvider client={supportClient} openFile={shareSupportFile}>
+  <Navigation />
+</SupportProvider>;
+```
+
+On both platforms the person picks the app to open or save the file with; on Android this is
+the share chooser rather than an "open with" list. If the file cannot be
+opened, the person sees a short message and can try again.

package/lib/commonjs/SupportProvider.js

@@ -0,0 +1,335 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSupportTickets = exports.useSupportTicket = exports.useSupportConfig = exports.useSupportClient = exports.useCreateSupportTicket = exports.useAttachmentOpener = exports.useAttachmentLoader = exports.SupportProvider = void 0;
+var _react = require("react");
+var _client = require("./client.js");
+var _files = require("./files.js");
+var _jsxRuntime = require("react/jsx-runtime");
+/** A downloaded attachment, ready for the OS to open. */
+
+/** Hands a downloaded file to the OS. `shareSupportFile` from the `/share` entry is one. */
+
+const SupportContext = /*#__PURE__*/(0, _react.createContext)(null);
+const SupportProvider = ({
+  client,
+  openFile,
+  children
+}) => {
+  const [config, setConfig] = (0, _react.useState)(null);
+  const [configError, setConfigError] = (0, _react.useState)(null);
+  const [configLoading, setConfigLoading] = (0, _react.useState)(true);
+  const [revision, setRevision] = (0, _react.useState)(0);
+  // Attachments never change once stored, so each is fetched once per session.
+  const attachments = (0, _react.useRef)(new Map());
+  const reloadConfig = (0, _react.useCallback)(async () => {
+    setConfigLoading(true);
+    try {
+      setConfig(await client.getConfig());
+      setConfigError(null);
+    } catch (error) {
+      setConfigError((0, _client.toSupportApiError)(error));
+    } finally {
+      setConfigLoading(false);
+    }
+  }, [client]);
+  (0, _react.useEffect)(() => {
+    attachments.current.clear();
+    void reloadConfig();
+  }, [reloadConfig]);
+  const loadAttachment = (0, _react.useCallback)(attachment => {
+    const cached = attachments.current.get(attachment.id);
+    if (cached) {
+      return cached;
+    }
+    const pending = client.getAttachmentDataUri(attachment);
+    attachments.current.set(attachment.id, pending);
+    pending.catch(() => attachments.current.delete(attachment.id));
+    return pending;
+  }, [client]);
+  const openAttachment = (0, _react.useMemo)(() => openFile ? async attachment => {
+    const uri = await (0, _files.saveAttachmentToCache)(attachment, () => client.getAttachmentBytes(attachment.id));
+    await openFile({
+      uri,
+      name: attachment.fileName,
+      contentType: attachment.contentType
+    });
+  } : null, [client, openFile]);
+  const bumpRevision = (0, _react.useCallback)(() => setRevision(r => r + 1), []);
+  const value = (0, _react.useMemo)(() => ({
+    client,
+    config,
+    configError,
+    configLoading,
+    reloadConfig,
+    loadAttachment,
+    openAttachment,
+    revision,
+    bumpRevision
+  }), [client, config, configError, configLoading, reloadConfig, loadAttachment, openAttachment, revision, bumpRevision]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(SupportContext.Provider, {
+    value: value,
+    children: children
+  });
+};
+exports.SupportProvider = SupportProvider;
+const useSupportContext = () => {
+  const ctx = (0, _react.useContext)(SupportContext);
+  if (!ctx) {
+    throw new Error('[@webority/mobile-support] Support screens and hooks need a <SupportProvider client={...}> above them.');
+  }
+  return ctx;
+};
+const useSupportClient = () => useSupportContext().client;
+
+/** @internal Used by the attachment thumbnails. */
+exports.useSupportClient = useSupportClient;
+const useAttachmentLoader = () => useSupportContext().loadAttachment;
+
+/** @internal Used by the file rows; null when the app gave no `openFile`. */
+exports.useAttachmentLoader = useAttachmentLoader;
+const useAttachmentOpener = () => useSupportContext().openAttachment;
+exports.useAttachmentOpener = useAttachmentOpener;
+const useSupportConfig = () => {
+  const {
+    config,
+    configLoading,
+    configError,
+    reloadConfig
+  } = useSupportContext();
+  return {
+    config,
+    loading: configLoading,
+    error: configError,
+    reload: reloadConfig
+  };
+};
+exports.useSupportConfig = useSupportConfig;
+const DEFAULT_PAGE_SIZE = 20;
+const useSupportTickets = (options = {}) => {
+  const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+  const {
+    client,
+    revision
+  } = useSupportContext();
+  const [status, setStatus] = (0, _react.useState)(null);
+  const [search, setSearch] = (0, _react.useState)('');
+  const [tickets, setTickets] = (0, _react.useState)([]);
+  const [counts, setCounts] = (0, _react.useState)(null);
+  const [page, setPage] = (0, _react.useState)(0);
+  const [totalPages, setTotalPages] = (0, _react.useState)(0);
+  const [loading, setLoading] = (0, _react.useState)(true);
+  const [refreshing, setRefreshing] = (0, _react.useState)(false);
+  const [loadingMore, setLoadingMore] = (0, _react.useState)(false);
+  const [error, setError] = (0, _react.useState)(null);
+  const [loadMoreError, setLoadMoreError] = (0, _react.useState)(null);
+  const mounted = (0, _react.useRef)(true);
+  // Each first-page load takes a new number; a response carrying an older one
+  // belongs to a filter or search the person has already left, and is dropped.
+  const sequence = (0, _react.useRef)(0);
+  const moreInFlight = (0, _react.useRef)(false);
+  // The client whose counts are on screen; null until a load with counts lands.
+  const countsFrom = (0, _react.useRef)(null);
+  (0, _react.useEffect)(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const query = (0, _react.useCallback)(nextPage => ({
+    status: status ?? undefined,
+    search: search.trim() || undefined,
+    page: nextPage,
+    pageSize
+  }), [status, search, pageSize]);
+  const loadFirstPage = (0, _react.useCallback)(async mode => {
+    sequence.current += 1;
+    const seq = sequence.current;
+    const current = () => mounted.current && seq === sequence.current;
+    moreInFlight.current = false;
+    setLoadingMore(false);
+    if (mode === 'refresh') {
+      setRefreshing(true);
+    } else if (mode === 'replace') {
+      setLoading(true);
+      setTickets([]);
+    }
+    // Counts ignore the status and search, so a filter change keeps the ones it has.
+    const withCounts = mode !== 'replace' || countsFrom.current !== client;
+    try {
+      const [first, nextCounts] = await Promise.all([client.listTickets(query(1)), withCounts ? client.getTicketCounts() : null]);
+      if (current()) {
+        setTickets(first.items);
+        setPage(first.page);
+        setTotalPages(first.totalPages);
+        if (nextCounts) {
+          setCounts(nextCounts);
+          countsFrom.current = client;
+        }
+        setError(null);
+        setLoadMoreError(null);
+      }
+    } catch (e) {
+      if (current()) {
+        setError((0, _client.toSupportApiError)(e));
+      }
+    } finally {
+      if (current()) {
+        setLoading(false);
+        setRefreshing(false);
+      }
+    }
+  }, [client, query]);
+  const seenRevision = (0, _react.useRef)(revision);
+  (0, _react.useEffect)(() => {
+    // A write elsewhere refetches without blanking the rows on screen.
+    const mode = seenRevision.current === revision ? 'replace' : 'quiet';
+    seenRevision.current = revision;
+    void loadFirstPage(mode);
+  }, [loadFirstPage, revision]);
+  const hasMore = page < totalPages;
+  const loadMore = (0, _react.useCallback)(async () => {
+    if (moreInFlight.current || loading || refreshing || !hasMore) {
+      return;
+    }
+    const seq = sequence.current;
+    const current = () => mounted.current && seq === sequence.current;
+    moreInFlight.current = true;
+    setLoadingMore(true);
+    setLoadMoreError(null);
+    try {
+      const next = await client.listTickets(query(page + 1));
+      if (current()) {
+        // Order is by last update, so a ticket that changed between two pages
+        // can arrive twice.
+        setTickets(prev => {
+          const ids = new Set(prev.map(t => t.id));
+          return [...prev, ...next.items.filter(t => !ids.has(t.id))];
+        });
+        setPage(next.page);
+        setTotalPages(next.totalPages);
+      }
+    } catch (e) {
+      if (current()) {
+        setLoadMoreError((0, _client.toSupportApiError)(e));
+      }
+    } finally {
+      if (current()) {
+        moreInFlight.current = false;
+        setLoadingMore(false);
+      }
+    }
+  }, [client, query, page, hasMore, loading, refreshing]);
+  const refresh = (0, _react.useCallback)(() => loadFirstPage('refresh'), [loadFirstPage]);
+  const createTicket = useCreateSupportTicket();
+  return {
+    tickets,
+    counts,
+    status,
+    search,
+    setStatus,
+    setSearch,
+    loading,
+    refreshing,
+    loadingMore,
+    hasMore,
+    error,
+    loadMoreError,
+    refresh,
+    loadMore,
+    createTicket
+  };
+};
+
+/** Raises a ticket and tells every mounted ticket list to refetch. */
+exports.useSupportTickets = useSupportTickets;
+const useCreateSupportTicket = () => {
+  const {
+    client,
+    bumpRevision
+  } = useSupportContext();
+  return (0, _react.useCallback)(async input => {
+    const created = await client.createTicket(input);
+    bumpRevision();
+    return created;
+  }, [client, bumpRevision]);
+};
+exports.useCreateSupportTicket = useCreateSupportTicket;
+const useSupportTicket = id => {
+  const {
+    client,
+    bumpRevision
+  } = useSupportContext();
+  const [ticket, setTicket] = (0, _react.useState)(null);
+  const [loading, setLoading] = (0, _react.useState)(true);
+  const [error, setError] = (0, _react.useState)(null);
+  const [actionError, setActionError] = (0, _react.useState)(null);
+  const [busy, setBusy] = (0, _react.useState)(false);
+  const mounted = (0, _react.useRef)(true);
+  (0, _react.useEffect)(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const reload = (0, _react.useCallback)(async () => {
+    setLoading(true);
+    try {
+      const next = await client.getTicket(id);
+      if (mounted.current) {
+        setTicket(next);
+        setError(null);
+      }
+    } catch (e) {
+      if (mounted.current) {
+        setError((0, _client.toSupportApiError)(e));
+      }
+    } finally {
+      if (mounted.current) {
+        setLoading(false);
+      }
+    }
+  }, [client, id]);
+  (0, _react.useEffect)(() => {
+    void reload();
+  }, [reload]);
+  const act = (0, _react.useCallback)(async run => {
+    setBusy(true);
+    setActionError(null);
+    try {
+      const next = await run();
+      if (mounted.current) {
+        setTicket(next);
+      }
+      bumpRevision();
+      return true;
+    } catch (e) {
+      if (mounted.current) {
+        setActionError((0, _client.toSupportApiError)(e));
+      }
+      return false;
+    } finally {
+      if (mounted.current) {
+        setBusy(false);
+      }
+    }
+  }, [bumpRevision]);
+  const reply = (0, _react.useCallback)(input => act(() => client.reply(id, input)), [act, client, id]);
+  const reopen = (0, _react.useCallback)(() => act(() => client.reopen(id)), [act, client, id]);
+  const rate = (0, _react.useCallback)(input => act(() => client.rate(id, input)), [act, client, id]);
+  return {
+    ticket,
+    loading,
+    error,
+    actionError,
+    busy,
+    reload,
+    reply,
+    reopen,
+    rate
+  };
+};
+exports.useSupportTicket = useSupportTicket;
+//# sourceMappingURL=SupportProvider.js.map

package/lib/commonjs/client.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toSupportApiError = exports.encodeBase64 = exports.createSupportClient = exports.SupportApiError = exports.OFFLINE_MESSAGE = exports.GENERIC_MESSAGE = void 0;
+/**
+ * The slice of an HTTP client the support client needs. The app's signed-in
+ * axios instance (mobile-core's `userClient`, or its own) satisfies it as is, so
+ * whatever it adds to a request (bearer token, tenant header, refresh on 401)
+ * applies to support calls too. Declared structurally so no axios type leaks into
+ * this package's declarations.
+ */
+
+const OFFLINE_MESSAGE = exports.OFFLINE_MESSAGE = 'You are offline. Check your connection and try again.';
+const GENERIC_MESSAGE = exports.GENERIC_MESSAGE = 'Something went wrong. Try again in a moment.';
+
+/**
+ * A failed support call. `message` is written for the person and is shown as is;
+ * `code` is the backend's stable code, for branching only.
+ */
+class SupportApiError extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.name = 'SupportApiError';
+    this.code = code;
+    this.status = status;
+  }
+}
+exports.SupportApiError = SupportApiError;
+/** Turns whatever the HTTP client threw into a SupportApiError. */
+const toSupportApiError = error => {
+  if (error instanceof SupportApiError) {
+    return error;
+  }
+  const e = error ?? {};
+  // By name, not instanceof: a second copy of mobile-core would fail instanceof.
+  if (e.name === 'RequestOfflineError') {
+    return new SupportApiError('offline', OFFLINE_MESSAGE, null);
+  }
+  const status = typeof e.response?.status === 'number' ? e.response.status : null;
+  const data = e.response?.data;
+  if (data && typeof data.message === 'string' && data.message.trim()) {
+    const code = typeof data.code === 'string' ? data.code : 'unknown';
+    return new SupportApiError(code, data.message, status);
+  }
+  if (!e.response) {
+    return new SupportApiError('network', OFFLINE_MESSAGE, null);
+  }
+  return new SupportApiError('unknown', GENERIC_MESSAGE, status);
+};
+
+// Photo uploads get the fleet's multipart timeout, not the 30 s JSON one.
+exports.toSupportApiError = toSupportApiError;
+const UPLOAD_TIMEOUT_MS = 300000;
+const MULTIPART = {
+  'Content-Type': 'multipart/form-data'
+};
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const encodeBase64 = buffer => {
+  const bytes = new Uint8Array(buffer);
+  let out = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : undefined;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : undefined;
+    out += B64[b0 >> 2];
+    out += B64[(b0 & 0x03) << 4 | (b1 ?? 0) >> 4];
+    out += b1 === undefined ? '=' : B64[(b1 & 0x0f) << 2 | (b2 ?? 0) >> 6];
+    out += b2 === undefined ? '=' : B64[b2 & 0x3f];
+  }
+  return out;
+};
+exports.encodeBase64 = encodeBase64;
+const appendParts = (form, field, parts) => {
+  for (const part of parts ?? []) {
+    // React Native's FormData takes a { uri, name, type } object as a file part.
+    form.append(field, {
+      uri: part.uri,
+      name: part.name,
+      type: part.type
+    });
+  }
+};
+const appendText = (form, field, value) => {
+  if (value !== undefined && value !== '') {
+    form.append(field, value);
+  }
+};
+const queryString = query => {
+  const pairs = [];
+  const add = (key, value) => {
+    if (value !== undefined && value !== '') {
+      pairs.push(`${key}=${encodeURIComponent(String(value))}`);
+    }
+  };
+  add('status', query.status);
+  add('search', query.search?.trim());
+  add('page', query.page);
+  add('pageSize', query.pageSize);
+  return pairs.length > 0 ? `?${pairs.join('&')}` : '';
+};
+const createSupportClient = (http, basePath = '/api/support') => {
+  const base = basePath.replace(/\/+$/, '');
+  const ticketUrl = id => `${base}/tickets/${encodeURIComponent(id)}`;
+  const call = async request => {
+    try {
+      const response = await request();
+      return response.data;
+    } catch (error) {
+      throw toSupportApiError(error);
+    }
+  };
+  const getBytes = id => call(() => http.get(`${base}/attachments/${encodeURIComponent(id)}`, {
+    responseType: 'arraybuffer'
+  }));
+  return {
+    basePath: base,
+    getConfig: () => call(() => http.get(`${base}/settings`)),
+    listTickets: (query = {}) => call(() => http.get(`${base}/tickets${queryString(query)}`)),
+    getTicketCounts: () => call(() => http.get(`${base}/tickets/counts`)),
+    getTicket: id => call(() => http.get(ticketUrl(id))),
+    createTicket: input => {
+      const form = new FormData();
+      form.append('category', input.category);
+      form.append('subject', input.subject);
+      form.append('body', input.body);
+      appendText(form, 'pageUrl', input.pageUrl);
+      appendText(form, 'userAgent', input.userAgent);
+      appendText(form, 'appVersion', input.appVersion);
+      appendParts(form, 'files', input.files);
+      appendParts(form, 'screenshots', input.screenshots);
+      return call(() => http.post(`${base}/tickets`, form, {
+        headers: MULTIPART,
+        timeout: UPLOAD_TIMEOUT_MS
+      }));
+    },
+    reply: (id, input) => {
+      const form = new FormData();
+      form.append('body', input.body);
+      appendParts(form, 'files', input.files);
+      appendParts(form, 'screenshots', input.screenshots);
+      return call(() => http.post(`${ticketUrl(id)}/replies`, form, {
+        headers: MULTIPART,
+        timeout: UPLOAD_TIMEOUT_MS
+      }));
+    },
+    reopen: id => call(() => http.post(`${ticketUrl(id)}/reopen`)),
+    rate: (id, input) => call(() => http.post(`${ticketUrl(id)}/rating`, {
+      satisfaction: input.satisfaction,
+      comment: input.comment?.trim() ? input.comment.trim() : null
+    })),
+    getAttachmentBytes: getBytes,
+    getAttachmentDataUri: async attachment => {
+      const bytes = await getBytes(attachment.id);
+      return `data:${attachment.contentType};base64,${encodeBase64(bytes)}`;
+    },
+    confirmAction: token => call(() => http.post(`${base}/actions/confirm`, {
+      token
+    }))
+  };
+};
+exports.createSupportClient = createSupportClient;
+//# sourceMappingURL=client.js.map

package/lib/commonjs/clipboard.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copyText = void 0;
+/** The one place `expo-clipboard` is named. */
+const copyText = text => require('expo-clipboard').setStringAsync(text);
+exports.copyText = copyText;
+//# sourceMappingURL=clipboard.js.map