@nihinmedia/medgen-react-native 1.0.12

package/lib/commonjs/index.js

@@ -0,0 +1,204 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _exportNames = {
+  MedGen: true,
+  MedGenHost: true,
+  MedGenSurface: true,
+  SDK_VERSION: true
+};
+
+exports.MedGenSurface = exports.MedGenHost = exports.MedGen = void 0;
+
+Object.defineProperty(exports, "SDK_VERSION", {
+  enumerable: true,
+  get: function() {
+    return _client.SDK_VERSION;
+  }
+});
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactNative = require("react-native");
+
+var _client = require("./client");
+
+var _MedGenWebView = require("./MedGenWebView");
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function(key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function() {
+      return _types[key];
+    }
+  });
+});
+
+function _interopRequireWildcard(e, t) {
+  if ("function" == typeof WeakMap) var r = new WeakMap, n = new WeakMap;
+  return (_interopRequireWildcard = function(e, t) {
+    if (!t && e && e.__esModule) return e;
+    var o, i, f = {
+      __proto__: null,
+      default: e
+    };
+    if (null === e || "object" != typeof e && "function" != typeof e) return f;
+    if (o = t ? n : r) {
+      if (o.has(e)) return o.get(e);
+      o.set(e, f);
+    }
+    for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]);
+    return f;
+  })(e, t);
+}
+
+const hostRef = {
+  current: null
+};
+
+const teardowns = new Set;
+
+const MedGen = exports.MedGen = {
+  initialize(config) {
+    if (!config.assertionProvider && !config.assertion) {
+      throw new _types.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 _types.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.");
+    }
+    (0, _client.configure)(config);
+  },
+  async present(options) {
+    if (!hostRef.current) {
+      throw new _types.MedGenError("NOT_INITIALIZED", "Mount <MedGenHost /> near the root of your app");
+    }
+    await hostRef.current(options);
+  },
+  async signOut() {
+    teardowns.forEach(fn => {
+      try {
+        fn();
+      } catch {}
+    });
+    await (0, _client.clearCredentials)();
+  }
+};
+
+const MedGenHost = () => {
+  const [url, setUrl] = (0, _react.useState)(null);
+  const [capabilities, setCapabilities] = (0, _react.useState)(null);
+  const present = (0, _react.useCallback)(async options => {
+    const result = await (0, _client.exchange)();
+    setCapabilities(result.capabilities);
+    setUrl((0, _client.buildEmbedUrl)(result.handoffCode, options?.entryQuestion, result.capabilities));
+    (0, _client.emit)("surface.opened");
+  }, []);
+  (0, _react.useEffect)(() => {
+    hostRef.current = present;
+    return () => {
+      if (hostRef.current === present) hostRef.current = null;
+    };
+  }, [ present ]);
+  const close = (0, _react.useCallback)(() => {
+    setUrl(null);
+    setCapabilities(null);
+    (0, _client.emit)("surface.closed");
+  }, []);
+  (0, _react.useEffect)(() => {
+    teardowns.add(close);
+    return () => {
+      teardowns.delete(close);
+    };
+  }, [ close ]);
+  return _react.default.createElement(_reactNative.Modal, {
+    visible: url !== null,
+    animationType: "slide",
+    presentationStyle: "fullScreen",
+    onRequestClose: close
+  }, _react.default.createElement(_reactNative.SafeAreaView, {
+    style: styles.container
+  }, url && capabilities ? _react.default.createElement(_MedGenWebView.MedGenWebView, {
+    url: url,
+    handlers: (0, _client.requireConfig)().nativeHandlers ?? {},
+    capabilities: capabilities,
+    onClose: close
+  }) : null));
+};
+
+exports.MedGenHost = MedGenHost;
+
+const MedGenSurface = ({visible: visible = true, options: options, onError: onError, onClose: onClose}) => {
+  const [url, setUrl] = (0, _react.useState)(null);
+  const [capabilities, setCapabilities] = (0, _react.useState)(null);
+  const [loading, setLoading] = (0, _react.useState)(false);
+  const started = (0, _react.useRef)(false);
+  (0, _react.useEffect)(() => {
+    if (!visible || started.current) return;
+    started.current = true;
+    setLoading(true);
+    (0, _client.exchange)().then(result => {
+      setCapabilities(result.capabilities);
+      setUrl((0, _client.buildEmbedUrl)(result.handoffCode, options?.entryQuestion, result.capabilities));
+      (0, _client.emit)("surface.opened");
+    }).catch(e => {
+      started.current = false;
+      onError?.(e);
+    }).finally(() => setLoading(false));
+  }, [ visible, options, onError ]);
+  (0, _react.useEffect)(() => {
+    const reset = () => {
+      setUrl(null);
+      setCapabilities(null);
+      started.current = false;
+    };
+    teardowns.add(reset);
+    return () => {
+      teardowns.delete(reset);
+    };
+  }, []);
+  return _react.default.createElement(_reactNative.View, {
+    style: [ styles.container, !visible && styles.hidden ],
+    pointerEvents: visible ? "auto" : "none"
+  }, url && capabilities ? _react.default.createElement(_MedGenWebView.MedGenWebView, {
+    url: url,
+    handlers: (0, _client.requireConfig)().nativeHandlers ?? {},
+    capabilities: capabilities,
+    onClose: () => {
+      setUrl(null);
+      setCapabilities(null);
+      started.current = false;
+      onClose?.();
+    }
+  }) : _react.default.createElement(_reactNative.View, {
+    style: styles.loading
+  }, loading ? _react.default.createElement(_reactNative.ActivityIndicator, {
+    size: "large"
+  }) : null));
+};
+
+exports.MedGenSurface = MedGenSurface;
+
+const styles = _reactNative.StyleSheet.create({
+  container: {
+    flex: 1
+  },
+  hidden: {
+    display: "none"
+  },
+  loading: {
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center"
+  }
+});

package/lib/commonjs/native.js

@@ -0,0 +1,201 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.writeClipboard = exports.shareText = exports.shareFile = exports.saveToDownloads = exports.renderPdf = exports.registerNativeModules = exports.ensureStoragePermission = exports.canShareText = exports.canSaveToDownloads = exports.canRenderPdf = exports.canCopy = void 0;
+
+var _reactNative = require("react-native");
+
+var _pdfLinks = require("./pdfLinks");
+
+let registry = {};
+
+const registerNativeModules = mods => {
+  registry = {
+    ...registry,
+    ...mods
+  };
+};
+
+exports.registerNativeModules = registerNativeModules;
+
+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");
+
+const ensureStoragePermission = async () => {
+  if (_reactNative.Platform.OS !== "android") return true;
+  if (typeof _reactNative.Platform.Version === "number" && _reactNative.Platform.Version >= 29) return true;
+  const permission = _reactNative.PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE;
+  if (!permission) return false;
+  try {
+    const granted = await _reactNative.PermissionsAndroid.request(permission, {
+      title: "Save to your device",
+      message: "MedGen needs permission to save this document.",
+      buttonPositive: "Allow"
+    });
+    return granted === _reactNative.PermissionsAndroid.RESULTS.GRANTED;
+  } catch {
+    return false;
+  }
+};
+
+exports.ensureStoragePermission = ensureStoragePermission;
+
+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;
+  }
+};
+
+exports.writeClipboard = writeClipboard;
+
+const canShareText = () => true;
+
+exports.canShareText = canShareText;
+
+const canCopy = () => loadClipboard() !== null;
+
+exports.canCopy = canCopy;
+
+const canRenderPdf = () => loadHtmlToPdf() !== null;
+
+exports.canRenderPdf = canRenderPdf;
+
+const canSaveToDownloads = () => _reactNative.Platform.OS === "android" && loadBlobUtil() !== null;
+
+exports.canSaveToDownloads = canSaveToDownloads;
+
+const shareText = async text => {
+  try {
+    const result = await _reactNative.Share.share({
+      message: text
+    });
+    return result.action !== _reactNative.Share.dismissedAction;
+  } catch {
+    return false;
+  }
+};
+
+exports.shareText = shareText;
+
+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"
+    };
+  }
+};
+
+exports.shareFile = shareFile;
+
+const renderPdf = async (html, fileName, links = []) => {
+  const HtmlToPdf = loadHtmlToPdf();
+  if (!HtmlToPdf) return null;
+  const withLinks = _reactNative.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;
+  }
+};
+
+exports.renderPdf = renderPdf;
+
+const writeLinks = async (filePath, base64, links) => {
+  const Blob = loadBlobUtil();
+  if (!Blob?.fs?.writeFile) return;
+  try {
+    const linked = await (0, _pdfLinks.addPdfLinks)(base64, links);
+    await Blob.fs.writeFile(filePath, linked, "base64");
+  } catch {}
+};
+
+const saveToDownloads = async (sourcePath, fileName) => {
+  const Blob = loadBlobUtil();
+  if (_reactNative.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 (_reactNative.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"
+    };
+  }
+};
+
+exports.saveToDownloads = saveToDownloads;

package/lib/commonjs/pdfLinks.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.sanitizeLinks = exports.addPdfLinks = void 0;
+
+var _pdfLib = require("pdf-lib");
+
+const MAX_LINKS = 2e3;
+
+const isFiniteNumber = n => typeof n === "number" && Number.isFinite(n);
+
+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);
+  });
+};
+
+exports.sanitizeLinks = sanitizeLinks;
+
+const pdfLiteral = url => url.replace(/[^\x20-\x7E]/g, c => encodeURIComponent(c)).replace(/[\\()]/g, c => `\\${c}`);
+
+const addPdfLinks = async (base64, links) => {
+  const doc = await _pdfLib.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: _pdfLib.PDFString.of(pdfLiteral(link.url))
+      }
+    });
+    page.node.addAnnot(doc.context.register(annot));
+  }
+  return doc.saveAsBase64({
+    useObjectStreams: false
+  });
+};
+
+exports.addPdfLinks = addPdfLinks;

package/lib/commonjs/types.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.MedGenError = exports.MedGenEnvironment = void 0;
+
+let MedGenEnvironment = exports.MedGenEnvironment = function(MedGenEnvironment) {
+  MedGenEnvironment["Development"] = "development";
+  MedGenEnvironment["Staging"] = "staging";
+  MedGenEnvironment["Production"] = "production";
+  return MedGenEnvironment;
+}({});
+
+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);
+  }
+}
+
+exports.MedGenError = MedGenError;

package/lib/module/MedGenWebView.js

@@ -0,0 +1,166 @@
+import React, { useCallback, useMemo, useRef } from "react";
+
+import { ActivityIndicator, Linking, StyleSheet, View } from "react-native";
+
+import { WebView as RNWebView } from "react-native-webview";
+
+const WebView = RNWebView;
+
+import { handleBridgeMessage } from "./bridge";
+
+import { embedBase, emit, SDK_VERSION } from "./client";
+
+export const originOf = u => {
+  const m = /^[a-z][a-z0-9+.-]*:\/\/[^/?#]+/i.exec(u);
+  return m ? m[0].toLowerCase() : "";
+};
+
+export const decideNavigation = (url, base, isTopFrame) => {
+  if (isSameOrigin(url, base)) return "load";
+  if (isTopFrame === false) return "block";
+  if (/^(mailto|tel|sms):/i.test(url)) return "external";
+  if (!/^https?:\/\//i.test(url)) return "block";
+  return "external";
+};
+
+const openExternally = async url => {
+  try {
+    if (!await Linking.canOpenURL(url)) {
+      emit("surface.externalLinkFailed", {
+        url: url,
+        reason: "unsupported"
+      });
+      return false;
+    }
+    await Linking.openURL(url);
+    emit("surface.externalLinkOpened", {
+      url: url
+    });
+    return true;
+  } catch (error) {
+    emit("surface.externalLinkFailed", {
+      url: url,
+      reason: error instanceof Error ? error.message : "unknown"
+    });
+    return false;
+  }
+};
+
+const makeNonce = () => `${Date.now().toString(36)}.${Math.random().toString(36).slice(2)}${Math.random().toString(36).slice(2)}`;
+
+export const isSameOrigin = (target, base) => {
+  if (target === "about:blank") return true;
+  const b = originOf(base);
+  return b !== "" && originOf(target) === b;
+};
+
+export const MedGenWebView = ({url: url, handlers: handlers, capabilities: capabilities, onClose: onClose}) => {
+  const ref = useRef(null);
+  const nonce = useMemo(() => makeNonce(), [ url ]);
+  const isMedGenOrigin = useCallback(target => isSameOrigin(target, embedBase()), []);
+  const onShouldStartLoadWithRequest = useCallback(req => {
+    const decision = decideNavigation(req.url, embedBase(), req.isTopFrame);
+    if (decision === "load") return true;
+    if (decision === "external") void openExternally(req.url);
+    return false;
+  }, [ isMedGenOrigin ]);
+  const onMessage = useCallback(event => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      try {
+        const probe = JSON.parse(event.nativeEvent.data);
+        if (probe?.__medgenLog) {
+          const {level: level = "log", args: args = []} = probe.__medgenLog;
+          console[level === "error" ? "error" : "warn"]("[MedGen surface]", ...args);
+          return;
+        }
+      } catch {}
+    }
+    if (!isMedGenOrigin(event.nativeEvent.url)) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn("[MedGen] message rejected — origin not allowed:", event.nativeEvent.url);
+      }
+      return;
+    }
+    void handleBridgeMessage(event.nativeEvent.data, replyJson => {
+      const safe = JSON.stringify(replyJson).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+      ref.current?.injectJavaScript(`window.__medgen && window.__medgen.receive(${safe}); true;`);
+    }, {
+      handlers: handlers,
+      capabilities: capabilities,
+      onClose: onClose,
+      nonce: nonce
+    });
+  }, [ isMedGenOrigin, handlers, capabilities, onClose, nonce ]);
+  return React.createElement(WebView, {
+    ref: ref,
+    source: {
+      uri: url
+    },
+    style: styles.web,
+    injectedJavaScriptBeforeContentLoaded: `window.__medgenNonce=${JSON.stringify(nonce)};` + (typeof __DEV__ !== "undefined" && __DEV__ ? `(function(){var p=window.ReactNativeWebView&&window.ReactNativeWebView.postMessage;` + `if(!p)return;['log','warn','error'].forEach(function(l){var o=console[l];` + `console[l]=function(){try{p.call(window.ReactNativeWebView,JSON.stringify(` + `{__medgenLog:{level:l,args:Array.prototype.slice.call(arguments).map(String)}}));}` + `catch(e){}o&&o.apply(console,arguments);};});})();` : "") + `true;`,
+    injectedJavaScriptBeforeContentLoadedForMainFrameOnly: true,
+    originWhitelist: [ originOf(embedBase()) ],
+    onShouldStartLoadWithRequest: onShouldStartLoadWithRequest,
+    onMessage: onMessage,
+    allowFileAccess: false,
+    allowUniversalAccessFromFileURLs: false,
+    mixedContentMode: "never",
+    javaScriptCanOpenWindowsAutomatically: false,
+    setSupportMultipleWindows: false,
+    onOpenWindow: event => {
+      const url = event?.nativeEvent?.targetUrl;
+      if (!url) return;
+      const decision = decideNavigation(url, embedBase(), true);
+      if (decision === "load") {
+        ref.current?.injectJavaScript(`window.location.assign(${JSON.stringify(url)});true;`);
+      } else if (decision === "external") {
+        void openExternally(url);
+      }
+    },
+    onError: event => {
+      emit("surface.loadFailed", {
+        description: event?.nativeEvent?.description,
+        code: event?.nativeEvent?.code
+      });
+    },
+    onHttpError: event => {
+      emit("surface.loadFailed", {
+        statusCode: event?.nativeEvent?.statusCode
+      });
+    },
+    automaticallyAdjustContentInsets: false,
+    contentInsetAdjustmentBehavior: "never",
+    keyboardDisplayRequiresUserAction: false,
+    androidLayerType: "hardware",
+    onContentProcessDidTerminate: () => {
+      emit("surface.loadFailed", {
+        reason: "content_process_terminated"
+      });
+      ref.current?.reload();
+    },
+    allowsInlineMediaPlayback: true,
+    allowsLinkPreview: false,
+    applicationNameForUserAgent: `MedGenSDK/${SDK_VERSION}`,
+    sharedCookiesEnabled: true,
+    thirdPartyCookiesEnabled: false,
+    startInLoadingState: true,
+    renderLoading: () => React.createElement(View, {
+      style: styles.loading
+    }, React.createElement(ActivityIndicator, {
+      size: "large"
+    })),
+    bounces: false,
+    overScrollMode: "never"
+  });
+};
+
+const styles = StyleSheet.create({
+  web: {
+    flex: 1
+  },
+  loading: {
+    ...StyleSheet.absoluteFillObject,
+    alignItems: "center",
+    justifyContent: "center"
+  }
+});