@nihinmedia/medgen-react-native 1.0.12

package/lib/module/index.js

@@ -0,0 +1,152 @@
+import React, { useCallback, useEffect, useRef, useState } from "react";
+
+import { ActivityIndicator, Modal, SafeAreaView, StyleSheet, View } from "react-native";
+
+import { buildEmbedUrl, clearCredentials, configure, emit, exchange, requireConfig } from "./client";
+
+import { MedGenWebView } from "./MedGenWebView";
+
+import { MedGenError } from "./types";
+
+export * from "./types";
+
+export { SDK_VERSION } from "./client";
+
+const hostRef = {
+  current: null
+};
+
+const teardowns = new Set;
+
+export const MedGen = {
+  initialize(config) {
+    if (!config.assertionProvider && !config.assertion) {
+      throw new MedGenError("NOT_INITIALIZED", "MedGen.initialize() needs assertionProvider (or, to try the SDK once, assertion)");
+    }
+    if (!config.assertionProvider && config.assertion) {
+      if (typeof __DEV__ !== "undefined" && !__DEV__) {
+        throw new MedGenError("NOT_INITIALIZED", "A static `assertion` cannot be used in a release build — it is " + "single-use and cannot be refreshed. Set `assertionProvider`.");
+      }
+      console.warn("[MedGen] Using a static `assertion`. It is single-use and expires " + "after 120s, so only the first present() will succeed. Set " + "`assertionProvider` before shipping.");
+    }
+    configure(config);
+  },
+  async present(options) {
+    if (!hostRef.current) {
+      throw new MedGenError("NOT_INITIALIZED", "Mount <MedGenHost /> near the root of your app");
+    }
+    await hostRef.current(options);
+  },
+  async signOut() {
+    teardowns.forEach(fn => {
+      try {
+        fn();
+      } catch {}
+    });
+    await clearCredentials();
+  }
+};
+
+export const MedGenHost = () => {
+  const [url, setUrl] = useState(null);
+  const [capabilities, setCapabilities] = useState(null);
+  const present = useCallback(async options => {
+    const result = await exchange();
+    setCapabilities(result.capabilities);
+    setUrl(buildEmbedUrl(result.handoffCode, options?.entryQuestion, result.capabilities));
+    emit("surface.opened");
+  }, []);
+  useEffect(() => {
+    hostRef.current = present;
+    return () => {
+      if (hostRef.current === present) hostRef.current = null;
+    };
+  }, [ present ]);
+  const close = useCallback(() => {
+    setUrl(null);
+    setCapabilities(null);
+    emit("surface.closed");
+  }, []);
+  useEffect(() => {
+    teardowns.add(close);
+    return () => {
+      teardowns.delete(close);
+    };
+  }, [ close ]);
+  return React.createElement(Modal, {
+    visible: url !== null,
+    animationType: "slide",
+    presentationStyle: "fullScreen",
+    onRequestClose: close
+  }, React.createElement(SafeAreaView, {
+    style: styles.container
+  }, url && capabilities ? React.createElement(MedGenWebView, {
+    url: url,
+    handlers: requireConfig().nativeHandlers ?? {},
+    capabilities: capabilities,
+    onClose: close
+  }) : null));
+};
+
+export const MedGenSurface = ({visible: visible = true, options: options, onError: onError, onClose: onClose}) => {
+  const [url, setUrl] = useState(null);
+  const [capabilities, setCapabilities] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const started = useRef(false);
+  useEffect(() => {
+    if (!visible || started.current) return;
+    started.current = true;
+    setLoading(true);
+    exchange().then(result => {
+      setCapabilities(result.capabilities);
+      setUrl(buildEmbedUrl(result.handoffCode, options?.entryQuestion, result.capabilities));
+      emit("surface.opened");
+    }).catch(e => {
+      started.current = false;
+      onError?.(e);
+    }).finally(() => setLoading(false));
+  }, [ visible, options, onError ]);
+  useEffect(() => {
+    const reset = () => {
+      setUrl(null);
+      setCapabilities(null);
+      started.current = false;
+    };
+    teardowns.add(reset);
+    return () => {
+      teardowns.delete(reset);
+    };
+  }, []);
+  return React.createElement(View, {
+    style: [ styles.container, !visible && styles.hidden ],
+    pointerEvents: visible ? "auto" : "none"
+  }, url && capabilities ? React.createElement(MedGenWebView, {
+    url: url,
+    handlers: requireConfig().nativeHandlers ?? {},
+    capabilities: capabilities,
+    onClose: () => {
+      setUrl(null);
+      setCapabilities(null);
+      started.current = false;
+      onClose?.();
+    }
+  }) : React.createElement(View, {
+    style: styles.loading
+  }, loading ? React.createElement(ActivityIndicator, {
+    size: "large"
+  }) : null));
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1
+  },
+  hidden: {
+    display: "none"
+  },
+  loading: {
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center"
+  }
+});

package/lib/module/native.js

@@ -0,0 +1,171 @@
+import { PermissionsAndroid, Platform, Share } from "react-native";
+
+import { addPdfLinks } from "./pdfLinks";
+
+let registry = {};
+
+export const registerNativeModules = mods => {
+  registry = {
+    ...registry,
+    ...mods
+  };
+};
+
+const unwrap = mod => mod?.default ?? mod;
+
+const fromRegistry = key => {
+  const mod = registry[key];
+  return mod ? unwrap(mod) : null;
+};
+
+const loadClipboard = () => fromRegistry("clipboard");
+
+const loadShare = () => fromRegistry("share");
+
+const loadHtmlToPdf = () => fromRegistry("htmlToPdf");
+
+const loadBlobUtil = () => fromRegistry("blobUtil");
+
+export const ensureStoragePermission = async () => {
+  if (Platform.OS !== "android") return true;
+  if (typeof Platform.Version === "number" && Platform.Version >= 29) return true;
+  const permission = PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE;
+  if (!permission) return false;
+  try {
+    const granted = await PermissionsAndroid.request(permission, {
+      title: "Save to your device",
+      message: "MedGen needs permission to save this document.",
+      buttonPositive: "Allow"
+    });
+    return granted === PermissionsAndroid.RESULTS.GRANTED;
+  } catch {
+    return false;
+  }
+};
+
+export const writeClipboard = async (text, html) => {
+  const Clipboard = loadClipboard();
+  if (!Clipboard) return false;
+  try {
+    if (html && typeof Clipboard.setStringHTML === "function") {
+      Clipboard.setStringHTML(html, text);
+    } else {
+      Clipboard.setString(text);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const canShareText = () => true;
+
+export const canCopy = () => loadClipboard() !== null;
+
+export const canRenderPdf = () => loadHtmlToPdf() !== null;
+
+export const canSaveToDownloads = () => Platform.OS === "android" && loadBlobUtil() !== null;
+
+export const shareText = async text => {
+  try {
+    const result = await Share.share({
+      message: text
+    });
+    return result.action !== Share.dismissedAction;
+  } catch {
+    return false;
+  }
+};
+
+export const shareFile = async (uri, mimeType = "application/pdf", fileName) => {
+  const RNShare = loadShare();
+  if (!RNShare) return {
+    saved: false,
+    reason: "no_module"
+  };
+  try {
+    await RNShare.open({
+      url: uri.startsWith("file://") ? uri : `file://${uri}`,
+      type: mimeType,
+      filename: fileName,
+      failOnCancel: false
+    });
+    return {
+      saved: true,
+      uri: uri
+    };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : "";
+    return {
+      saved: false,
+      reason: /cancel/i.test(msg) ? "cancelled" : "failed"
+    };
+  }
+};
+
+export const renderPdf = async (html, fileName, links = []) => {
+  const HtmlToPdf = loadHtmlToPdf();
+  if (!HtmlToPdf) return null;
+  const withLinks = Platform.OS === "ios" && links.length > 0;
+  try {
+    const {filePath: filePath, base64: base64} = await HtmlToPdf.convert({
+      html: html,
+      fileName: fileName.replace(/\.pdf$/i, ""),
+      directory: "Documents",
+      base64: withLinks
+    });
+    if (filePath && withLinks && base64) await writeLinks(filePath, base64, links);
+    return filePath ?? null;
+  } catch {
+    return null;
+  }
+};
+
+const writeLinks = async (filePath, base64, links) => {
+  const Blob = loadBlobUtil();
+  if (!Blob?.fs?.writeFile) return;
+  try {
+    const linked = await addPdfLinks(base64, links);
+    await Blob.fs.writeFile(filePath, linked, "base64");
+  } catch {}
+};
+
+export const saveToDownloads = async (sourcePath, fileName) => {
+  const Blob = loadBlobUtil();
+  if (Platform.OS !== "android") return {
+    saved: false,
+    reason: "no_module"
+  };
+  if (!Blob) return {
+    saved: false,
+    reason: "no_module"
+  };
+  if (!await ensureStoragePermission()) {
+    return {
+      saved: false,
+      reason: "permission_denied"
+    };
+  }
+  try {
+    const target = `${Blob.fs.dirs.DownloadDir}/${fileName}`;
+    await Blob.fs.cp(sourcePath.replace("file://", ""), target);
+    if (Platform.OS === "android" && Blob.android?.addCompleteDownload) {
+      Blob.android.addCompleteDownload({
+        title: fileName,
+        description: "MedGen document",
+        mime: "application/pdf",
+        path: target,
+        showNotification: true
+      });
+    }
+    return {
+      saved: true,
+      uri: target
+    };
+  } catch {
+    return {
+      saved: false,
+      reason: "failed"
+    };
+  }
+};

package/lib/module/pdfLinks.js

@@ -0,0 +1,45 @@
+import { PDFDocument, PDFString } from "pdf-lib";
+
+const MAX_LINKS = 2e3;
+
+const isFiniteNumber = n => typeof n === "number" && Number.isFinite(n);
+
+export const sanitizeLinks = raw => {
+  if (!Array.isArray(raw)) return [];
+  return raw.slice(0, MAX_LINKS).filter(l => {
+    const link = l;
+    return !!link && Number.isInteger(link.page) && link.page >= 0 && [ link.x, link.y, link.width, link.height ].every(isFiniteNumber) && link.width > 0 && link.height > 0 && typeof link.url === "string" && /^https?:\/\/[^\s]+$/i.test(link.url);
+  });
+};
+
+const pdfLiteral = url => url.replace(/[^\x20-\x7E]/g, c => encodeURIComponent(c)).replace(/[\\()]/g, c => `\\${c}`);
+
+export const addPdfLinks = async (base64, links) => {
+  const doc = await PDFDocument.load(base64);
+  const pages = doc.getPages();
+  for (const link of links) {
+    const page = pages[link.page];
+    if (!page) continue;
+    const {width: pw, height: ph} = page.getSize();
+    const left = Math.max(0, link.x);
+    const right = Math.min(pw, link.x + link.width);
+    const top = Math.min(ph, ph - link.y);
+    const bottom = Math.max(0, ph - link.y - link.height);
+    if (right <= left || top <= bottom) continue;
+    const annot = doc.context.obj({
+      Type: "Annot",
+      Subtype: "Link",
+      Rect: [ left, bottom, right, top ],
+      Border: [ 0, 0, 0 ],
+      A: {
+        Type: "Action",
+        S: "URI",
+        URI: PDFString.of(pdfLiteral(link.url))
+      }
+    });
+    page.node.addAnnot(doc.context.register(annot));
+  }
+  return doc.saveAsBase64({
+    useObjectStreams: false
+  });
+};

package/lib/module/types.js

@@ -0,0 +1,17 @@
+export let MedGenEnvironment = function(MedGenEnvironment) {
+  MedGenEnvironment["Development"] = "development";
+  MedGenEnvironment["Staging"] = "staging";
+  MedGenEnvironment["Production"] = "production";
+  return MedGenEnvironment;
+}({});
+
+export class MedGenError extends Error {
+  constructor(code, message, retryable = false, supportReference) {
+    super(message);
+    this.name = "MedGenError";
+    this.code = code;
+    this.retryable = retryable;
+    this.supportReference = supportReference;
+    Object.setPrototypeOf(this, MedGenError.prototype);
+  }
+}

package/lib/typescript/MedGenWebView.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { MedGenCapabilities, MedGenNativeHandlers } from './types';
+
+export declare const originOf: (u: string) => string;
+
+export type NavigationDecision = 'load' | 'external' | 'block';
+export declare const decideNavigation: (url: string, base: string, isTopFrame?: boolean) => NavigationDecision;
+
+export declare const isSameOrigin: (target: string, base: string) => boolean;
+interface Props {
+    url: string;
+    handlers: MedGenNativeHandlers;
+    capabilities: MedGenCapabilities;
+    onClose: () => void;
+}
+
+export declare const MedGenWebView: React.FC<Props>;
+export {};

package/lib/typescript/bridge.d.ts

@@ -0,0 +1,12 @@
+import { MedGenCapabilities, MedGenNativeHandlers } from './types';
+type Reply = (json: string) => void;
+export interface BridgeContext {
+    handlers: MedGenNativeHandlers;
+    capabilities: MedGenCapabilities;
+    onClose: () => void;
+    
+    nonce: string;
+}
+
+export declare function handleBridgeMessage(raw: string, reply: Reply, ctx: BridgeContext): Promise<void>;
+export {};

package/lib/typescript/client.d.ts

@@ -0,0 +1,30 @@
+import { MedGenBranding, ExchangeResult, MedGenCapabilities, MedGenConfig, MedGenEventName } from './types';
+export declare const SDK_VERSION = "1.0.12";
+
+export declare function configure(cfg: MedGenConfig): void;
+
+export declare function resetConfig(): void;
+
+export declare function requireConfig(): MedGenConfig;
+export declare const apiBase: () => string;
+export declare const embedBase: () => string;
+
+export declare function emit(name: MedGenEventName, detail?: Record<string, unknown>): void;
+export interface Credentials {
+    access: string;
+    refresh: string;
+}
+
+export declare function storeCredentials(creds: Credentials): Promise<void>;
+
+export declare function readCredentials(): Promise<Credentials | null>;
+
+export declare function clearCredentials(): Promise<void>;
+
+export declare function parseBranding(raw: unknown): MedGenBranding;
+
+export declare function parseCapabilities(raw: unknown): MedGenCapabilities;
+
+export declare function exchange(): Promise<ExchangeResult>;
+
+export declare function buildEmbedUrl(handoffCode: string, entryQuestion?: string, capabilities?: MedGenCapabilities): string;

package/lib/typescript/index.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { MedGenConfig, MedGenError, MedGenPresentOptions } from './types';
+export * from './types';
+export { SDK_VERSION } from './client';
+export declare const MedGen: {
+    
+    initialize(config: MedGenConfig): void;
+    
+    present(options?: MedGenPresentOptions): Promise<void>;
+    
+    signOut(): Promise<void>;
+};
+
+export declare const MedGenHost: React.FC;
+
+export declare const MedGenSurface: React.FC<{
+    
+    visible?: boolean;
+    options?: MedGenPresentOptions;
+    onError?: (e: MedGenError) => void;
+    
+    onClose?: () => void;
+}>;

package/lib/typescript/native.d.ts

@@ -0,0 +1,38 @@
+import { type PdfLink } from './pdfLinks';
+
+export interface OptionalNativeModules {
+    
+    clipboard?: unknown;
+    
+    share?: unknown;
+    
+    htmlToPdf?: unknown;
+    
+    blobUtil?: unknown;
+}
+
+export declare const registerNativeModules: (mods: OptionalNativeModules) => void;
+
+export interface SaveResult {
+    saved: boolean;
+    
+    uri?: string;
+    reason?: 'no_module' | 'permission_denied' | 'cancelled' | 'failed';
+}
+
+export declare const ensureStoragePermission: () => Promise<boolean>;
+
+export declare const writeClipboard: (text: string, html?: string) => Promise<boolean>;
+
+export declare const canShareText: () => boolean;
+export declare const canCopy: () => boolean;
+export declare const canRenderPdf: () => boolean;
+export declare const canSaveToDownloads: () => boolean;
+
+export declare const shareText: (text: string) => Promise<boolean>;
+
+export declare const shareFile: (uri: string, mimeType?: string, fileName?: string) => Promise<SaveResult>;
+
+export declare const renderPdf: (html: string, fileName: string, links?: PdfLink[]) => Promise<string | null>;
+
+export declare const saveToDownloads: (sourcePath: string, fileName: string) => Promise<SaveResult>;

package/lib/typescript/pdfLinks.d.ts

@@ -0,0 +1,14 @@
+export interface PdfLink {
+    
+    page: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    
+    url: string;
+}
+
+export declare const sanitizeLinks: (raw: unknown) => PdfLink[];
+
+export declare const addPdfLinks: (base64: string, links: PdfLink[]) => Promise<string>;