ink-framework 0.0.0-stage → 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vandam Dinh
+
+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/ink-native.json

@@ -0,0 +1,33 @@
+{
+  "version": 1,
+  "modules": {
+    "src/image.ts": [
+      "image",
+      "network"
+    ],
+    "src/input.ts": [
+      "text-input"
+    ],
+    "src/playing.ts": [
+      "image",
+      "network",
+      "ui-playing"
+    ],
+    "src/external.ts": [
+      "external"
+    ],
+    "src/native-list.ts": [
+      "ui-lists"
+    ],
+    "src/list.ts": [
+      "ui-lists"
+    ],
+    "src/conversation.ts": [
+      "ui-messages",
+      "ui-lists"
+    ],
+    "src/canvas.ts": [
+      "ui-canvas"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "ink-framework",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.1",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./renderer": "./src/renderer.ts",
+    "./internal/list": "./src/native-list.ts",
+    "./internal/playback": "./src/playback-binding.ts",
+    "./native": "./src/native.ts",
+    "./native/controller": "./src/controller.ts",
+    "./assets": "./src/assets.ts",
+    "./icons": "./src/icons.ts",
+    "./file-router": "./src/file-router.tsx",
+    "./runtime-types": "./runtime.d.ts",
+    "./tsconfig": "./tsconfig.app.json"
+  },
+  "dependencies": {
+    "linkify-it": "^6.1.0",
+    "react-reconciler": "0.33.0"
+  },
+  "peerDependencies": {
+    "react": "19.2.8"
+  },
+  "sideEffects": [
+    "./src/native.ts"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/No-Scrolling/ink.git",
+    "directory": "packages/ink"
+  },
+  "files": [
+    "src",
+    "*.json",
+    "*.ts"
+  ]
+}

package/runtime.d.ts

@@ -0,0 +1,81 @@
+export {};
+
+declare global {
+  interface ImportMeta {
+    readonly env: { readonly [key: `INK_PUBLIC_${string}`]: string | undefined };
+  }
+  function setTimeout<T extends unknown[]>(callback: (...args: T) => void, delay?: number, ...args: T): number;
+  function setInterval<T extends unknown[]>(callback: (...args: T) => void, delay?: number, ...args: T): number;
+  function clearTimeout(id?: number): void;
+  function clearInterval(id?: number): void;
+  function queueMicrotask(callback: () => void): void;
+  const performance: { now(): number; readonly timeOrigin: number };
+  const console: { log(...values: unknown[]): void; info(...values: unknown[]): void; warn(...values: unknown[]): void; error(...values: unknown[]): void; debug(...values: unknown[]): void };
+
+  class TextEncoder {
+    readonly encoding: "utf-8";
+    encode(input?: string): Uint8Array<ArrayBuffer>;
+    encodeInto(input: string, destination: Uint8Array): { read: number; written: number };
+  }
+  class TextDecoder {
+    constructor(label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean });
+    readonly encoding: "utf-8";
+    readonly fatal: boolean;
+    readonly ignoreBOM: boolean;
+    decode(input?: ArrayBuffer | ArrayBufferView, options?: { stream?: boolean }): string;
+  }
+  class DOMException extends Error {
+    constructor(message?: string, name?: string);
+    readonly code: number;
+  }
+  interface EventInit { bubbles?: boolean; cancelable?: boolean; composed?: boolean }
+  class Event {
+    constructor(type: string, options?: EventInit);
+    readonly type: string;
+    readonly bubbles: boolean;
+    readonly cancelable: boolean;
+    readonly composed: boolean;
+    readonly target: EventTarget | null;
+    readonly currentTarget: EventTarget | null;
+    readonly eventPhase: number;
+    readonly defaultPrevented: boolean;
+    readonly timeStamp: number;
+    readonly isTrusted: false;
+    cancelBubble: boolean;
+    returnValue: boolean;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+    preventDefault(): void;
+    composedPath(): EventTarget[];
+    static readonly NONE: 0; static readonly CAPTURING_PHASE: 1; static readonly AT_TARGET: 2; static readonly BUBBLING_PHASE: 3;
+    readonly NONE: 0; readonly CAPTURING_PHASE: 1; readonly AT_TARGET: 2; readonly BUBBLING_PHASE: 3;
+  }
+  class CustomEvent<T = unknown> extends Event {
+    constructor(type: string, options?: EventInit & { detail?: T });
+    readonly detail: T;
+  }
+  type EventListener = (event: Event) => void;
+  interface EventListenerObject { handleEvent(event: Event): void }
+  interface EventListenerOptions { capture?: boolean }
+  interface AddEventListenerOptions extends EventListenerOptions { once?: boolean; passive?: boolean; signal?: AbortSignal }
+  class EventTarget {
+    addEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListener | EventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: Event): boolean;
+  }
+  class AbortSignal extends EventTarget {
+    private constructor();
+    readonly aborted: boolean;
+    readonly reason: unknown;
+    onabort: ((event: Event) => void) | null;
+    throwIfAborted(): void;
+    static abort(reason?: unknown): AbortSignal;
+    static timeout(milliseconds: number): AbortSignal;
+    static any(signals: Iterable<AbortSignal>): AbortSignal;
+  }
+  class AbortController {
+    readonly signal: AbortSignal;
+    abort(reason?: unknown): void;
+  }
+
+}

package/src/action.ts

@@ -0,0 +1,49 @@
+import { useCallback, useEffect, useRef, useState } from "./react";
+
+type ActionState<T> =
+  | { status: "idle" }
+  | { status: "pending" }
+  | { status: "success"; data: T }
+  | { status: "error"; error: Error };
+
+export type Action<T, Args extends unknown[]> = ActionState<T> & {
+  run: (...args: Args) => void;
+};
+
+export function useAction<T, Args extends unknown[]>(
+  operation: (...args: Args) => T | PromiseLike<T>,
+): Action<T, Args> {
+  const [state, setState] = useState<ActionState<T>>({ status: "idle" });
+  const mounted = useRef(false);
+  const pending = useRef<object | null>(null);
+
+  useEffect(() => {
+    mounted.current = true;
+    setState(current => current.status === "pending" ? { status: "idle" } : current);
+    return () => {
+      mounted.current = false;
+      pending.current = null;
+    };
+  }, []);
+
+  const run = useCallback((...args: Args) => {
+    if (!mounted.current || pending.current) return;
+    const request = {};
+    pending.current = request;
+    setState({ status: "pending" });
+    const finish = (result: ActionState<T>) => {
+      if (pending.current !== request) return;
+      pending.current = null;
+      setState(result);
+    };
+    void (async () => {
+      try {
+        finish({ status: "success", data: await operation(...args) });
+      } catch (error) {
+        finish({ status: "error", error: error instanceof Error ? error : new Error(String(error)) });
+      }
+    })();
+  }, [operation]);
+
+  return { ...state, run };
+}

package/src/appearance.ts

@@ -0,0 +1,24 @@
+import { useSyncExternalStore } from "./react";
+
+declare const __inkPost: (message: string) => void;
+
+export type ColourScheme = "dark" | "light";
+let colourScheme: ColourScheme = "dark";
+const listeners = new Set<() => void>();
+
+export function setColourScheme(value: ColourScheme): void {
+  if (value !== "dark" && value !== "light") throw new TypeError("Invalid colour scheme");
+  if (value === colourScheme) return;
+  __inkPost(JSON.stringify({ type: "appearance", colourScheme: value }));
+  colourScheme = value;
+  for (const listener of listeners) listener();
+}
+
+export function useColourScheme(): ColourScheme {
+  return useSyncExternalStore(subscribe, () => colourScheme);
+}
+
+function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}

package/src/assets.d.ts

@@ -0,0 +1,45 @@
+declare module "*.db" {
+  const source: string;
+  export default source;
+}
+declare module "*.png" {
+  const source: string;
+  export default source;
+}
+declare module "*.jpg" {
+  const source: string;
+  export default source;
+}
+declare module "*.jpeg" {
+  const source: string;
+  export default source;
+}
+declare module "*.webp" {
+  const source: string;
+  export default source;
+}
+declare module "*.mp3" {
+  const source: string;
+  export default source;
+}
+declare module "*.mp4" {
+  const source: string;
+  export default source;
+}
+declare module "*.mov" {
+  const source: string;
+  export default source;
+}
+declare module "*.webm" {
+  const source: string;
+  export default source;
+}
+declare module "*.svg" {
+  const icon: import("./assets").IconAsset;
+  export default icon;
+}
+
+declare module "*.gif" {
+  const source: string;
+  export default source;
+}

package/src/assets.ts

@@ -0,0 +1,7 @@
+/** Reference imported from ink/icons or an SVG file. */
+export type IconAsset = string & { readonly __inkIcon: unique symbol };
+
+/** Unknown names in external data return undefined. */
+export function findIcon(collection: Readonly<Record<string, IconAsset>>, name: string): IconAsset | undefined {
+  return Object.hasOwn(collection, name) ? collection[name] : undefined;
+}

package/src/canvas.ts

@@ -0,0 +1,40 @@
+import type { ReactNode } from "react";
+import type { IconAsset } from "./assets";
+import { createElement } from "./react";
+
+type Bounds = { x: number; y: number; width: number; height: number };
+
+export function Canvas(props: { width: number; height: number; children?: ReactNode }) {
+  return createElement("Canvas", props);
+}
+
+export function Rectangle(props: Bounds & {
+  fill?: string;
+  stroke?: string;
+  strokeWidth?: number;
+  onPress?: () => void;
+  onLongPress?: () => void;
+  onDragEnter?: () => void;
+}) {
+  return createElement("CanvasRectangle", props);
+}
+
+export function CanvasText({ children, ...props }: Bounds & {
+  children: string | number;
+  size?: number;
+  colour?: string;
+  align?: "start" | "center" | "end";
+  tabularNumbers?: boolean;
+}) {
+  return createElement("CanvasText", { ...props, text: String(children) });
+}
+
+export function CanvasIcon({ size = 28, ...props }: {
+  x: number;
+  y: number;
+  name: IconAsset;
+  size?: number;
+  colour?: string;
+}) {
+  return createElement("CanvasIcon", { ...props, width: size, height: size });
+}

package/src/controller.ts

@@ -0,0 +1,43 @@
+import { callNative, NativeError, onNativeMessage } from "./native";
+
+const observers = new Map<number, (value: unknown) => void>();
+declare const __inkNextId: () => number;
+
+onNativeMessage("controller", message => {
+  if (typeof message.id !== "number") throw new NativeError("protocol", "Invalid controller event ID");
+  observers.get(message.id)?.(message.value);
+});
+
+export function attachNativeController(
+  module: string,
+  recipe: unknown,
+  observe: (value: unknown) => void,
+) {
+  if (observers.size >= 256) throw new NativeError("busy", "Too many native controllers");
+  const id = __inkNextId();
+  let disposed = false;
+  observers.set(id, observe);
+  const ready = callNative(module, "activate", recipe, { controller: id }).catch(error => {
+    disposed = true;
+    observers.delete(id);
+    throw error;
+  });
+  return {
+    id,
+    ready,
+    call(operation: string, payload: unknown = {}) {
+      if (disposed) return Promise.reject(new NativeError("unavailable", "Native controller is disposed"));
+      return ready.then(() => {
+        if (disposed) throw new NativeError("unavailable", "Native controller is disposed");
+        return callNative(module, operation, payload, { controller: id });
+      });
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      observers.delete(id);
+      try { await ready; } catch { return; }
+      await callNative(module, "deactivate", {}, { controller: id });
+    },
+  };
+}

package/src/conversation.ts

@@ -0,0 +1,205 @@
+import { createElement, useEffect, useRef, useState, type ComponentProps } from "./react";
+import { addFilled, closeFilled, sendFilled } from "./icons";
+import { Button, Image, List, Screen, Stack, Text, TextInput } from "./index";
+import { back, presentPage } from "./navigation";
+import { textLinks } from "./links";
+import type { LinkPreviewData } from "./link-preview";
+import tick from "./icons/conversation/tick.svg";
+import tickDouble from "./icons/conversation/tick-double.svg";
+import view from "./icons/conversation/view.svg";
+import { callNative } from "./native";
+import { openLink } from "./external";
+import { nativeListRow, nativeListTemplate } from "./native-list";
+
+export type ReplyPreview = { author: string; text: string; onPress?: () => void };
+export type MessageProps = {
+  text?: string;
+  onLinkPress?: (url: string) => void;
+  linkPreview?: LinkPreviewData;
+  filePreview?: { title: string; label: string; artwork?: string };
+  onFilePress?: () => void;
+  timestamp: number;
+  outgoing?: boolean;
+  author?: string;
+  image?: { src: string; width: number; height: number; onPress?: () => void };
+  reply?: ReplyPreview;
+  reactions?: string;
+  status?: "sending" | "sent" | "delivered" | "read" | "failed";
+  onRetry?: () => void;
+  onLongPress?: () => void;
+  onDoubleTap?: () => void;
+};
+
+const statusIcons = { sending: tick, sent: tick, delivered: tickDouble, read: view };
+
+function messageTime(timestamp: number) {
+  const date = new Date(timestamp);
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const day = `${months[date.getMonth()]} ${date.getDate()}`;
+  const time = `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+  return date.toDateString() === new Date().toDateString() ? time : `${day} ${time}`;
+}
+
+function Reply({ author, text, onPress }: ReplyPreview) {
+  return createElement("Pressable", { onPress },
+    createElement("MessageQuote", null,
+      createElement(Stack, { gap: 3 },
+        createElement(Text, { size: 14 }, `Replying to ${author}`),
+        createElement(Text, { size: 14, maxLines: 1 }, text))));
+}
+
+const messageTemplate = /* @__PURE__ */ nativeListTemplate((node, field) => node("MessageContent", Object.fromEntries([
+  "outgoing", "label", "reactions", "statusIcon", "statusMuted", "reply", "image", "preview", "parts",
+  "onPress", "onLongPress", "onRetry", "onImagePress", "onReplyPress", "onLinkPress", "onPreviewPress",
+].map(name => [name, field(name)]))));
+
+function messageFields({ text, onLinkPress = openLink, linkPreview, filePreview, onFilePress, timestamp, outgoing = false, author, image, reply,
+  reactions, status, onRetry, onLongPress }: MessageProps, onPress: () => void) {
+  const displayText = text && linkPreview && !filePreview
+    ? textLinks(text).filter(link => link.url === linkPreview.url).reverse()
+      .reduce((value, link) => value.slice(0, link.start) + value.slice(link.end), text).trim()
+    : text;
+  const parts: { text: string; url?: string }[] = [];
+  let offset = 0;
+  if (displayText) {
+    for (const link of textLinks(displayText)) {
+      parts.push({ text: displayText.slice(offset, link.start) });
+      parts.push({ text: displayText.slice(link.start, link.end), url: link.url });
+      offset = link.end;
+    }
+    parts.push({ text: displayText.slice(offset) });
+  }
+  const failed = outgoing && status === "failed";
+  return { outgoing, label: failed ? (onRetry ? "Tap to retry" : "Could not send")
+      : [!outgoing && author, messageTime(timestamp)].filter(Boolean).join(", "),
+    reactions, statusIcon: outgoing && status && status !== "failed" ? statusIcons[status] : undefined,
+    statusMuted: status === "sending", parts,
+    reply: reply && { author: reply.author, text: reply.text },
+    image: image && { src: image.src, width: image.width, height: image.height },
+    preview: filePreview ? { title: filePreview.title, domain: filePreview.label, thumbnail: filePreview.artwork } : linkPreview && { ...linkPreview, domain: linkPreview.url.replace(/^https?:\/\/(?:www\.)?/, "").split(/[/?#]/, 1)[0] },
+    onPress, onLongPress, onRetry: failed ? onRetry : undefined, onImagePress: image?.onPress,
+    onReplyPress: reply?.onPress, onLinkPress, onPreviewPress: filePreview ? onFilePress : linkPreview && (() => onLinkPress(linkPreview.url)),
+  };
+}
+
+function doubleTap(previous: { current: number }, callback?: () => void) {
+  const now = Date.now();
+  if (previous.current && now - previous.current < 300) {
+    previous.current = 0;
+    if (callback) { void callNative("interaction", "haptic", null); callback(); }
+  } else previous.current = now;
+}
+
+export function Message(props: MessageProps) {
+  const lastTap = useRef(0);
+  return createElement("MessageContent", messageFields(props, () => doubleTap(lastTap, props.onDoubleTap)));
+}
+
+export type MessageAction = { label: string; onPress: () => void };
+
+export type ConversationMessage = Pick<MessageProps, "text" | "timestamp" | "outgoing" | "author" | "reactions" | "status" | "linkPreview" | "filePreview"> & {
+  id: string;
+  image?: { src: string; width: number; height: number };
+  reply?: { author: string; text: string };
+};
+const messageKey = (message: ConversationMessage) => message.id;
+
+export type ConversationScreenProps<T extends ConversationMessage = ConversationMessage> = {
+  title: string;
+  rightAction?: ComponentProps<typeof Screen>["rightAction"];
+  group?: boolean;
+  messages: readonly T[];
+  draft: string;
+  onDraftChange: (draft: string) => void;
+  onSend: (message: { text: string; replyTo?: T }) => void;
+  onAttach?: () => void;
+  onRetry?: (message: T) => void;
+  onImagePress?: (message: T) => void;
+  onFilePress?: (message: T) => void;
+  onLinkPress?: (url: string) => void;
+  onDoubleTap?: (message: T) => void;
+  actions?: (message: T) => readonly MessageAction[];
+  onLoadOlder?: () => Promise<void>;
+  hasOlder?: boolean;
+  loading?: boolean;
+  sending?: boolean;
+};
+
+export function ConversationScreen<T extends ConversationMessage>({ title, rightAction, group = false, messages, draft, onDraftChange, onSend, onAttach, onRetry, onImagePress, onFilePress, onLinkPress, onDoubleTap, actions, onLoadOlder, hasOlder = false, loading = false, sending = false }: ConversationScreenProps<T>) {
+  const [reply, setReply] = useState<T>();
+  const [scrollToEnd, setScrollToEnd] = useState(0);
+  const taps = useRef(new Map<string, { current: number }>());
+  const previousMessages = useRef<Set<string> | null>(null);
+  useEffect(() => {
+    const previous = previousMessages.current;
+    const addedOutgoing = previous && messages.some(message => message.outgoing && message.status === "sending"
+      && !previous.has(message.id));
+    previousMessages.current = new Set(messages.map(message => message.id));
+    for (const key of taps.current.keys()) if (!previousMessages.current.has(key)) taps.current.delete(key);
+    if (addedOutgoing) setScrollToEnd(request => request + 1);
+  }, [messages]);
+  const text = draft.trim();
+  const send = () => {
+    if (!text || sending) return;
+    onSend({ text, replyTo: reply });
+    setReply(undefined);
+    setScrollToEnd(request => request + 1);
+  };
+  function replyPreview(message: T): ReplyPreview {
+    return { author: message.outgoing ? "You" : message.author ?? title, text: message.text || message.filePreview?.title || "Photo" };
+  }
+  function messageProps(message: T, onLongPress?: () => void): MessageProps {
+    const image = message.image;
+    return {
+      text: message.text, timestamp: message.timestamp, outgoing: message.outgoing,
+      onLinkPress, linkPreview: message.linkPreview,
+      filePreview: message.filePreview, onFilePress: onFilePress && (() => onFilePress(message)),
+      author: group ? message.author : undefined, reply: message.reply,
+      reactions: message.reactions, status: message.status,
+      image: image && { ...image, onPress: () => {
+        if (onImagePress) onImagePress(message);
+        else presentPage(createElement(Screen, { title: "Photo", centered: true },
+          createElement(Image, { ...image, fit: "contain", bleed: true, zoomable: true })));
+      } },
+      onRetry: onRetry && (() => onRetry(message)),
+      onDoubleTap: onDoubleTap && (() => onDoubleTap(message)),
+      onLongPress,
+    };
+  }
+  function renderMessage(message: T, onLongPress?: () => void) { return createElement(Message, messageProps(message, onLongPress)); }
+  function openMessage(message: T) {
+      presentPage(createElement(Screen, { title: "Message actions" },
+        renderMessage(message),
+        createElement(Button, { onPress: () => {
+          setReply(message);
+          setScrollToEnd(request => request + 1);
+          back();
+        } }, "Reply"),
+        actions?.(message).map((action, actionIndex) => createElement(Button, {
+          key: actionIndex,
+          onPress: () => { back(); action.onPress(); },
+        }, action.label))));
+  }
+  const messageItem = nativeListRow((message: T) => renderMessage(message, () => openMessage(message)), message => {
+    const props = messageProps(message, () => openMessage(message));
+    return [messageFields(props, () => {
+      let previous = taps.current.get(message.id);
+      if (!previous) { previous = { current: 0 }; taps.current.set(message.id, previous); }
+      doubleTap(previous, props.onDoubleTap);
+    })];
+  }, messageTemplate, { identity: "ink/conversation", usesIndex: false, values: () => [group, !!onRetry, !!onFilePress, new Date().toDateString()] });
+  const iconButton = (name: string, onPress?: () => void) => createElement("Pressable", { onPress },
+    createElement("Icon", { name, size: 28, tone: onPress ? "primary" : "muted" }));
+  return createElement("Screen", { title, rightIcon: rightAction?.icon, onRightPress: rightAction?.onPress, pinnedFooter: true, initialEnd: true, scrollToEnd },
+    loading ? createElement(Text, { size: 18, align: "center" }, "Loading…")
+      : createElement(List<T>, { items: messages, keyExtractor: messageKey, renderItem: messageItem, gap: 28, followEnd: true, initialPosition: "end", onLoadOlder, hasOlder }),
+    !loading && messages.length === 0 && createElement(Text, { size: 18, align: "center" }, "No messages yet"),
+    createElement(Stack, { gap: 8, align: "stretch" },
+      reply && createElement("ConversationComposer", null,
+        createElement(Reply, replyPreview(reply)), iconButton(closeFilled, () => setReply(undefined))),
+      createElement("ConversationComposer", null,
+        onAttach ? iconButton(addFilled, onAttach) : createElement(Stack),
+        createElement(TextInput, { value: draft, onChange: onDraftChange, placeholder: "Message…", action: "return" }),
+        iconButton(sendFilled, text && !sending ? send : undefined)),
+    ));
+}

package/src/external.ts

@@ -0,0 +1,13 @@
+import { callNative } from "./native";
+
+export async function openURL(url: string): Promise<void> {
+  await callNative("external", "open-url", { url }, { timeoutMs: 900_000 });
+}
+
+export function openLink(url: string): void {
+  void openURL(url).catch(error => console.error("Could not open link", error));
+}
+
+export async function share(options: { text: string }): Promise<void> {
+  await callNative("external", "share", options, { timeoutMs: 900_000 });
+}