@nihinmedia/medgen-react-native 1.0.9

package/lib/commonjs/client.js

@@ -0,0 +1,350 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.apiBase = exports.SDK_VERSION = void 0;
+
+exports.buildEmbedUrl = buildEmbedUrl;
+
+exports.clearCredentials = clearCredentials;
+
+exports.configure = configure;
+
+exports.embedBase = void 0;
+
+exports.emit = emit;
+
+exports.exchange = exchange;
+
+exports.parseCapabilities = parseCapabilities;
+
+exports.readCredentials = readCredentials;
+
+exports.requireConfig = requireConfig;
+
+exports.resetConfig = resetConfig;
+
+exports.storeCredentials = storeCredentials;
+
+var _reactNative = require("react-native");
+
+var Keychain = _interopRequireWildcard(require("react-native-keychain"));
+
+var _types = require("./types");
+
+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 KEYCHAIN_SERVICE = "jp.nihinmedia.medgen";
+
+const ASSERTION_TIMEOUT_MS = 1e4;
+
+const ATTESTATION_TIMEOUT_MS = 15e3;
+
+const SDK_VERSION = exports.SDK_VERSION = "1.0.9";
+
+const DEFAULT_API = {
+  development: "https://dev.sugoimed.com",
+  staging: "https://staging.sugoimed.com",
+  production: "https://medgen.nihinmedia.jp"
+};
+
+const DEFAULT_EMBED = {
+  development: "https://dev.sugoimed.com",
+  staging: "https://staging.sugoimed.com",
+  production: "https://medgen.nihinmedia.jp"
+};
+
+let config = null;
+
+function configure(cfg) {
+  config = cfg;
+}
+
+function resetConfig() {
+  config = null;
+}
+
+function requireConfig() {
+  if (!config) {
+    throw new _types.MedGenError("NOT_INITIALIZED", "Call MedGen.initialize() before present()");
+  }
+  return config;
+}
+
+function requireHttps(url, field) {
+  const lower = url.toLowerCase();
+  const isLocal = lower.startsWith("http://localhost") || lower.startsWith("http://127.0.0.1");
+  if (!lower.startsWith("https://") && !isLocal) {
+    throw new _types.MedGenError("NOT_INITIALIZED", `${field} must use https:// — refusing to send an assertion over plaintext`);
+  }
+  return url.replace(/\/+$/, "");
+}
+
+const apiBase = () => {
+  const cfg = requireConfig();
+  const base = cfg.apiBaseUrl ?? DEFAULT_API[cfg.environment] ?? DEFAULT_API.staging;
+  return requireHttps(base, "apiBaseUrl");
+};
+
+exports.apiBase = apiBase;
+
+const embedBase = () => {
+  const cfg = requireConfig();
+  const base = cfg.embedBaseUrl ?? DEFAULT_EMBED[cfg.environment] ?? DEFAULT_EMBED.staging;
+  return requireHttps(base, "embedBaseUrl");
+};
+
+exports.embedBase = embedBase;
+
+function emit(name, detail) {
+  const handler = config?.onEvent;
+  if (!handler) return;
+  const event = {
+    name: name,
+    at: Date.now(),
+    detail: detail
+  };
+  try {
+    handler(event);
+  } catch {}
+}
+
+async function storeCredentials(creds) {
+  await Keychain.setGenericPassword("medgen", JSON.stringify(creds), {
+    service: KEYCHAIN_SERVICE,
+    accessible: Keychain.ACCESSIBLE.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY
+  });
+}
+
+async function readCredentials() {
+  try {
+    const res = await Keychain.getGenericPassword({
+      service: KEYCHAIN_SERVICE
+    });
+    if (!res) return null;
+    return JSON.parse(res.password);
+  } catch {
+    return null;
+  }
+}
+
+async function clearCredentials() {
+  await Keychain.resetGenericPassword({
+    service: KEYCHAIN_SERVICE
+  });
+}
+
+function withTimeout(p, ms, code, what) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new _types.MedGenError(code, `${what} exceeded ${ms}ms`, true)), ms);
+  });
+  return Promise.race([ p, timeout ]).finally(() => clearTimeout(timer));
+}
+
+async function fetchAssertion() {
+  const {assertionProvider: assertionProvider, assertion: assertion} = requireConfig();
+  if (!assertionProvider) {
+    if (assertion) return assertion;
+    throw new _types.MedGenError("NOT_INITIALIZED", "Set assertionProvider (or, to try the SDK once, assertion) in MedGen.initialize()");
+  }
+  try {
+    return await withTimeout(assertionProvider(), ASSERTION_TIMEOUT_MS, "ASSERTION_PROVIDER_TIMEOUT", "Assertion provider");
+  } catch (e) {
+    if (e instanceof _types.MedGenError) throw e;
+    throw new _types.MedGenError("ASSERTION_PROVIDER_FAILED", e instanceof Error ? e.message : "Assertion provider failed", true);
+  }
+}
+
+async function fetchAttestation(assertion) {
+  const {attestationProvider: attestationProvider} = requireConfig();
+  if (!attestationProvider) return "";
+  try {
+    return await withTimeout(attestationProvider(assertion), ATTESTATION_TIMEOUT_MS, "ATTESTATION_FAILED", "Attestation provider");
+  } catch (e) {
+    if (e instanceof _types.MedGenError) throw e;
+    throw new _types.MedGenError("ATTESTATION_FAILED", e instanceof Error ? e.message : "Attestation provider failed", true);
+  }
+}
+
+const CAPABILITY_DEFAULTS = {
+  theming: false,
+  customLogo: false,
+  hideAttribution: false,
+  quickAnswer: true,
+  detailedAnswer: true,
+  japaneseAnswer: true,
+  dictation: false,
+  fileUpload: false,
+  clipboard: true,
+  richClipboard: true,
+  share: true,
+  chatHistory: true,
+  bookmarks: false,
+  citationsPanel: true,
+  directLink: true
+};
+
+function parseCapabilities(raw) {
+  const src = raw ?? {};
+  const pick = (key, fallback) => typeof src[key] === "boolean" ? src[key] : fallback;
+  return {
+    theming: pick("theming", CAPABILITY_DEFAULTS.theming),
+    customLogo: pick("custom_logo", CAPABILITY_DEFAULTS.customLogo),
+    hideAttribution: pick("hide_attribution", CAPABILITY_DEFAULTS.hideAttribution),
+    quickAnswer: pick("quick_answer", CAPABILITY_DEFAULTS.quickAnswer),
+    detailedAnswer: pick("detailed_answer", CAPABILITY_DEFAULTS.detailedAnswer),
+    japaneseAnswer: pick("japanese_answer", CAPABILITY_DEFAULTS.japaneseAnswer),
+    dictation: pick("dictation", CAPABILITY_DEFAULTS.dictation),
+    fileUpload: pick("file_upload", CAPABILITY_DEFAULTS.fileUpload),
+    clipboard: pick("clipboard", CAPABILITY_DEFAULTS.clipboard),
+    richClipboard: pick("rich_clipboard", CAPABILITY_DEFAULTS.richClipboard),
+    share: pick("share", CAPABILITY_DEFAULTS.share),
+    chatHistory: pick("chat_history", CAPABILITY_DEFAULTS.chatHistory),
+    bookmarks: pick("bookmarks", CAPABILITY_DEFAULTS.bookmarks),
+    citationsPanel: pick("citations_panel", CAPABILITY_DEFAULTS.citationsPanel),
+    directLink: pick("direct_link", CAPABILITY_DEFAULTS.directLink)
+  };
+}
+
+const CLIENT_BY_PLATFORM = {
+  ios: "sdk-ios",
+  android: "sdk-android"
+};
+
+async function exchange() {
+  emit("exchange.started");
+  const assertion = await fetchAssertion();
+  const attestation = await fetchAttestation(assertion);
+  const client = CLIENT_BY_PLATFORM[_reactNative.Platform.OS] ?? "sdk-ios";
+  const headers = {
+    "Content-Type": "application/json",
+    "X-MedGen-Client": `rn/${SDK_VERSION}`
+  };
+  if (attestation) headers["X-MedGen-Attestation"] = attestation;
+  let res;
+  try {
+    res = await fetch(`${apiBase()}/api/v1/partner/session/exchange`, {
+      method: "POST",
+      headers: headers,
+      body: JSON.stringify({
+        assertion: assertion,
+        client: client
+      })
+    });
+  } catch (e) {
+    const err = new _types.MedGenError("NETWORK_UNAVAILABLE", e instanceof Error ? e.message : "Network unavailable", true);
+    emit("exchange.failed", {
+      code: err.code
+    });
+    throw err;
+  }
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const err = new _types.MedGenError(body.error ?? "UNKNOWN", body.message ?? "Exchange failed", Boolean(body.retryable), body.support_reference);
+    emit("exchange.failed", {
+      code: err.code,
+      status: res.status
+    });
+    throw err;
+  }
+  const access = body.access;
+  const refresh = body.refresh;
+  if (typeof access !== "string" || !access || typeof refresh !== "string" || !refresh) {
+    const err = new _types.MedGenError("UNKNOWN", "Exchange response is missing session tokens", true);
+    emit("exchange.failed", {
+      code: err.code
+    });
+    throw err;
+  }
+  if (typeof body.handoff_code !== "string" || !body.handoff_code) {
+    const err = new _types.MedGenError("UNKNOWN", "Exchange response is missing a handoff code", true);
+    emit("exchange.failed", {
+      code: err.code
+    });
+    throw err;
+  }
+  await storeCredentials({
+    access: access,
+    refresh: refresh
+  });
+  const user = body.user ?? {};
+  const partner = body.partner ?? {};
+  const result = {
+    handoffCode: body.handoff_code,
+    isNewUser: Boolean(user.is_new),
+    emailCollisionPending: body.error === "EMAIL_COLLISION_PENDING",
+    brandingVersion: String(partner.branding_version ?? "1"),
+    capabilities: parseCapabilities(partner.capabilities ?? body.capabilities)
+  };
+  emit("exchange.succeeded", {
+    isNewUser: result.isNewUser,
+    emailCollisionPending: result.emailCollisionPending
+  });
+  return result;
+}
+
+const B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+function toBase64(input) {
+  const bytes = [];
+  const utf8 = encodeURIComponent(input);
+  for (let i = 0; i < utf8.length; i += 1) {
+    if (utf8[i] === "%") {
+      bytes.push(parseInt(utf8.substr(i + 1, 2), 16));
+      i += 2;
+    } else {
+      bytes.push(utf8.charCodeAt(i));
+    }
+  }
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = bytes[i + 1];
+    const b2 = bytes[i + 2];
+    out += B64_ALPHABET[b0 >> 2];
+    out += B64_ALPHABET[(b0 & 3) << 4 | (b1 ?? 0) >> 4];
+    out += b1 === undefined ? "=" : B64_ALPHABET[(b1 & 15) << 2 | (b2 ?? 0) >> 6];
+    out += b2 === undefined ? "=" : B64_ALPHABET[b2 & 63];
+  }
+  return out;
+}
+
+function buildEmbedUrl(handoffCode, entryQuestion, capabilities) {
+  const cfg = requireConfig();
+  const params = [ [ "hc", handoffCode ], [ "locale", cfg.locale ?? "ja" ] ];
+  if (cfg.theme && capabilities?.theming !== false) {
+    const branding = {
+      colors: {
+        primary: cfg.theme.primary,
+        secondary: cfg.theme.secondary,
+        accent: cfg.theme.accent,
+        surface: cfg.theme.surface,
+        onSurface: cfg.theme.onSurface
+      },
+      colorsDark: cfg.theme.darkVariant
+    };
+    params.push([ "theme", toBase64(JSON.stringify(branding)) ]);
+  }
+  if (entryQuestion) params.push([ "q", entryQuestion ]);
+  const query = params.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  return `${embedBase()}/embed?${query}`;
+}

package/lib/commonjs/index.js

@@ -0,0 +1,199 @@
+"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}) => {
+  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: () => undefined
+  }) : _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/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;