@mhosaic/feedback 0.3.0

package/dist/chunk-RSBFN26C.mjs

@@ -0,0 +1,745 @@
+// src/api/client.ts
+var SCALAR_FIELDS = [
+  "description",
+  "feedback_type",
+  "severity",
+  "env",
+  "page_url",
+  "user_agent",
+  "capture_method"
+];
+function createApiClient(options) {
+  const endpoint = options.endpoint ?? "https://core.mhosaic.com";
+  const fetcher = options.fetch ?? globalThis.fetch;
+  async function submitReport(input) {
+    let payload = input;
+    if (options.beforeSend) payload = await options.beforeSend(input);
+    if (payload === false) throw new Error("Submission cancelled by beforeSend");
+    const form = new FormData();
+    for (const field of SCALAR_FIELDS) {
+      form.append(field, String(payload[field]));
+    }
+    form.append("technical_context", JSON.stringify(payload.technical_context));
+    if (payload.screenshot) form.append("screenshot", payload.screenshot, "screenshot.png");
+    const response = await fetcher(`${endpoint}/api/feedback/v1/reports/`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${options.apiKey}` },
+      body: form
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`Feedback submit failed: ${response.status} ${text}`);
+    }
+    return response.json();
+  }
+  return { submitReport };
+}
+
+// src/capture/urlSanitizer.ts
+var SENSITIVE = /token|key|password|secret|auth|session|sig/i;
+function sanitizeUrl(url) {
+  try {
+    const isAbsolute = /^https?:\/\//i.test(url);
+    const isRootRelative = url.startsWith("/");
+    if (!isAbsolute && !isRootRelative) return url;
+    const base = typeof window !== "undefined" ? window.location.origin : "http://localhost";
+    const u = new URL(url, base);
+    const clean = new URLSearchParams();
+    u.searchParams.forEach((value, name) => {
+      clean.set(name, SENSITIVE.test(name) ? "[redacted]" : value);
+    });
+    u.search = clean.toString();
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+
+// src/capture/device.ts
+function collectDevice() {
+  const nav = navigator;
+  const connection = nav.connection?.effectiveType;
+  const deviceMemory = nav.deviceMemory;
+  const referrer = document.referrer || void 0;
+  return {
+    viewport: { w: window.innerWidth, h: window.innerHeight, dpr: window.devicePixelRatio || 1 },
+    screen: { w: window.screen.width, h: window.screen.height },
+    platform: nav.platform,
+    language: nav.language,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    timezoneOffset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+    ...connection !== void 0 && { connection },
+    online: nav.onLine,
+    ...deviceMemory !== void 0 && { deviceMemory },
+    hardwareConcurrency: nav.hardwareConcurrency,
+    ...referrer !== void 0 && { referrer },
+    title: document.title,
+    pathname: window.location.pathname
+  };
+}
+
+// src/capture/console.ts
+function safeStringify(arg) {
+  if (arg == null) return String(arg);
+  if (typeof arg === "string") return arg;
+  if (typeof arg === "number" || typeof arg === "boolean") return String(arg);
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  if (arg instanceof Element) return `<${arg.tagName.toLowerCase()}>`;
+  try {
+    return JSON.stringify(arg, (_k, v) => typeof v === "bigint" ? v.toString() : v);
+  } catch {
+    try {
+      return String(arg);
+    } catch {
+      return "[unserializable]";
+    }
+  }
+}
+function installConsolePatch(buffer) {
+  const levels = ["log", "info", "warn", "error", "debug"];
+  const originals = {};
+  for (const level of levels) {
+    const original = console[level];
+    if (typeof original !== "function") continue;
+    originals[level] = original;
+    console[level] = function patched(...args) {
+      try {
+        const message = args.map(safeStringify).join(" ").slice(0, 2e3);
+        const entry = { level, message, ts: Date.now() };
+        if (level === "error") {
+          const stack = new Error().stack;
+          if (stack) entry.stack = stack.split("\n").slice(2, 8).join("\n");
+        }
+        buffer.push(entry);
+      } catch {
+      }
+      original.apply(console, args);
+    };
+  }
+  return () => {
+    for (const [level, fn] of Object.entries(originals)) {
+      console[level] = fn;
+    }
+  };
+}
+
+// src/capture/network.ts
+function installFetchPatch(buffer, sanitize) {
+  if (typeof window === "undefined" || typeof window.fetch !== "function") return () => {
+  };
+  const original = window.fetch.bind(window);
+  window.fetch = async function patched(input, init) {
+    const start = performance.now();
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = (init?.method || (input instanceof Request ? input.method : "GET")).toUpperCase();
+    try {
+      const response = await original(input, init);
+      buffer.push({ url: sanitize(url), method, status: response.status, durationMs: Math.round(performance.now() - start), ts: Date.now() });
+      return response;
+    } catch (err) {
+      buffer.push({
+        url: sanitize(url),
+        method,
+        status: 0,
+        durationMs: Math.round(performance.now() - start),
+        ts: Date.now(),
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+  };
+  return () => {
+    window.fetch = original;
+  };
+}
+function installXhrPatch(buffer, sanitize) {
+  if (typeof window === "undefined" || typeof window.XMLHttpRequest !== "function") return () => {
+  };
+  const Original = window.XMLHttpRequest;
+  const originalOpen = Original.prototype.open;
+  const originalSend = Original.prototype.send;
+  Original.prototype.open = function patchedOpen(method, url) {
+    this.__mfb = { method: method.toUpperCase(), url: typeof url === "string" ? url : url.toString(), start: performance.now() };
+    return originalOpen.apply(this, arguments);
+  };
+  Original.prototype.send = function patchedSend(body) {
+    this.addEventListener("loadend", () => {
+      try {
+        const ctx = this.__mfb;
+        if (!ctx) return;
+        buffer.push({
+          url: sanitize(ctx.url),
+          method: ctx.method,
+          status: this.status,
+          durationMs: Math.round(performance.now() - ctx.start),
+          ts: Date.now()
+        });
+      } catch {
+      }
+    });
+    return originalSend.call(this, body ?? null);
+  };
+  return () => {
+    Original.prototype.open = originalOpen;
+    Original.prototype.send = originalSend;
+  };
+}
+
+// src/capture/errors.ts
+function installErrorHandlers(buffer) {
+  if (typeof window === "undefined") return () => {
+  };
+  const onError = (e) => {
+    const stack = e.error instanceof Error ? e.error.stack : void 0;
+    buffer.push({
+      message: e.message || "Unknown error",
+      ...stack !== void 0 && { stack },
+      ts: Date.now(),
+      source: "window.error"
+    });
+  };
+  const onRejection = (e) => {
+    const reason = e.reason;
+    const message = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : (() => {
+      try {
+        return JSON.stringify(reason);
+      } catch {
+        return String(reason);
+      }
+    })();
+    const stack = reason instanceof Error ? reason.stack : void 0;
+    buffer.push({
+      message,
+      ...stack !== void 0 && { stack },
+      ts: Date.now(),
+      source: "unhandledrejection"
+    });
+  };
+  window.addEventListener("error", onError);
+  window.addEventListener("unhandledrejection", onRejection);
+  return () => {
+    window.removeEventListener("error", onError);
+    window.removeEventListener("unhandledrejection", onRejection);
+  };
+}
+
+// src/capture/performance.ts
+function createPerformanceCollector(slowResourceMs = 1e3) {
+  const longTasks = [];
+  const slowResources = [];
+  let observer = null;
+  if (typeof PerformanceObserver !== "undefined") {
+    try {
+      observer = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          if (entry.entryType === "longtask") {
+            longTasks.push({ duration: entry.duration, startTime: entry.startTime });
+            while (longTasks.length > 20) longTasks.shift();
+          } else if (entry.entryType === "resource") {
+            const e = entry;
+            if (e.duration > slowResourceMs) {
+              slowResources.push({ name: e.name, duration: e.duration, initiatorType: e.initiatorType });
+              while (slowResources.length > 20) slowResources.shift();
+            }
+          }
+        }
+      });
+      observer.observe({ entryTypes: ["longtask", "resource"] });
+    } catch {
+    }
+  }
+  return {
+    snapshot() {
+      const nav = typeof performance !== "undefined" ? performance.getEntriesByType("navigation")[0] : void 0;
+      const navigation = nav ? { type: nav.type, duration: nav.duration } : void 0;
+      return {
+        ...navigation !== void 0 && { navigation },
+        longTasks: longTasks.slice(),
+        slowResources: slowResources.slice()
+      };
+    },
+    dispose() {
+      observer?.disconnect();
+    }
+  };
+}
+
+// src/capture/ringBuffer.ts
+var RingBuffer = class {
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  items = [];
+  push(item) {
+    this.items.push(item);
+    while (this.items.length > this.max) this.items.shift();
+  }
+  snapshot() {
+    return this.items.slice();
+  }
+  clear() {
+    this.items.length = 0;
+  }
+};
+
+// src/capture/index.ts
+function installCapture(options = {}) {
+  const { maxConsole = 50, maxNetwork = 50, maxErrors = 20 } = options;
+  const sanitize = options.sanitizeUrl ?? sanitizeUrl;
+  const consoleBuf = new RingBuffer(maxConsole);
+  const networkBuf = new RingBuffer(maxNetwork);
+  const errorBuf = new RingBuffer(maxErrors);
+  const uninstallConsole = installConsolePatch(consoleBuf);
+  const uninstallFetch = installFetchPatch(networkBuf, sanitize);
+  const uninstallXhr = installXhrPatch(networkBuf, sanitize);
+  const uninstallErrors = installErrorHandlers(errorBuf);
+  const perf = createPerformanceCollector();
+  return {
+    snapshot() {
+      return {
+        consoleLogs: consoleBuf.snapshot(),
+        networkRequests: networkBuf.snapshot(),
+        errors: errorBuf.snapshot(),
+        device: collectDevice(),
+        capturedAt: Date.now()
+      };
+    },
+    clear() {
+      consoleBuf.clear();
+      networkBuf.clear();
+      errorBuf.clear();
+    },
+    dispose() {
+      uninstallConsole();
+      uninstallFetch();
+      uninstallXhr();
+      uninstallErrors();
+      perf.dispose();
+    }
+  };
+}
+
+// src/screenshot/index.ts
+function isMaskedElement(el) {
+  return el.hasAttribute("data-mfb-mask") || el.classList.contains("mfb-mask");
+}
+function prepareMaskMatcher(selectors) {
+  const joined = selectors.join(",").trim();
+  if (!joined) return isMaskedElement;
+  return (el) => isMaskedElement(el) || el.matches(joined);
+}
+async function takeScreenshot(target, options = {}) {
+  if (typeof document === "undefined") return null;
+  try {
+    const html2canvas = (await import("html2canvas-pro")).default;
+    const matcher = prepareMaskMatcher(options.mask ?? []);
+    const canvas = await html2canvas(target, {
+      ignoreElements: (el) => matcher(el),
+      useCORS: true,
+      logging: false,
+      backgroundColor: null
+    });
+    return await new Promise((resolve) => canvas.toBlob(resolve, "image/png"));
+  } catch {
+    return null;
+  }
+}
+
+// src/widget/i18n.ts
+var DEFAULT_STRINGS = {
+  "fab.label": "Send feedback",
+  "form.title": "Send feedback",
+  "form.description.label": "What happened?",
+  "form.description.placeholder": "Describe the issue or idea in one or two sentences.",
+  "form.type.label": "Type",
+  "form.severity.label": "Severity",
+  "form.submit": "Send",
+  "form.cancel": "Cancel",
+  "form.submitting": "Sending\u2026",
+  "form.success": "Thanks \u2014 your feedback was sent.",
+  "form.error": "Could not send. Please try again.",
+  "type.bug": "Bug",
+  "type.feature": "Feature request",
+  "type.question": "Question",
+  "type.praise": "Praise",
+  "type.typo": "Typo",
+  "severity.blocker": "Blocker",
+  "severity.high": "High",
+  "severity.medium": "Medium",
+  "severity.low": "Low"
+};
+function resolveStrings(overrides) {
+  return { ...DEFAULT_STRINGS, ...overrides };
+}
+
+// src/widget/mount.tsx
+import { h, render } from "preact";
+import { useCallback } from "preact/hooks";
+
+// src/widget/Fab.tsx
+import { jsx } from "preact/jsx-runtime";
+function Fab({ label, onClick }) {
+  return /* @__PURE__ */ jsx("button", { type: "button", class: "fab", "aria-label": label, onClick, children: "\u{1F4AC}" });
+}
+
+// src/widget/Form.tsx
+import { useState } from "preact/hooks";
+import { jsx as jsx2, jsxs } from "preact/jsx-runtime";
+var TYPES = ["bug", "feature", "question", "praise", "typo"];
+var SEVERITIES = ["blocker", "high", "medium", "low"];
+function Form({ strings, onSubmit, onCancel, status, errorMessage }) {
+  const [description, setDescription] = useState("");
+  const [feedbackType, setFeedbackType] = useState("bug");
+  const [severity, setSeverity] = useState("medium");
+  const [localError, setLocalError] = useState("");
+  const submitting = status === "submitting";
+  const submitLabel = submitting ? strings["form.submitting"] : strings["form.submit"];
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    if (!description.trim()) {
+      setLocalError(strings["form.description.placeholder"]);
+      return;
+    }
+    setLocalError("");
+    onSubmit({ description: description.trim(), feedback_type: feedbackType, severity });
+  };
+  return /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, children: [
+    /* @__PURE__ */ jsx2("h2", { children: strings["form.title"] }),
+    /* @__PURE__ */ jsxs("div", { class: "field", children: [
+      /* @__PURE__ */ jsx2("label", { for: "mfb-desc", children: strings["form.description.label"] }),
+      /* @__PURE__ */ jsx2(
+        "textarea",
+        {
+          id: "mfb-desc",
+          value: description,
+          placeholder: strings["form.description.placeholder"],
+          onInput: (e) => setDescription(e.target.value)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { class: "row", children: [
+      /* @__PURE__ */ jsxs("div", { class: "field", children: [
+        /* @__PURE__ */ jsx2("label", { for: "mfb-type", children: strings["form.type.label"] }),
+        /* @__PURE__ */ jsx2(
+          "select",
+          {
+            id: "mfb-type",
+            value: feedbackType,
+            onChange: (e) => setFeedbackType(e.target.value),
+            children: TYPES.map((t) => /* @__PURE__ */ jsx2("option", { value: t, children: strings[`type.${t}`] }))
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { class: "field", children: [
+        /* @__PURE__ */ jsx2("label", { for: "mfb-sev", children: strings["form.severity.label"] }),
+        /* @__PURE__ */ jsx2(
+          "select",
+          {
+            id: "mfb-sev",
+            value: severity,
+            onChange: (e) => setSeverity(e.target.value),
+            children: SEVERITIES.map((s) => /* @__PURE__ */ jsx2("option", { value: s, children: strings[`severity.${s}`] }))
+          }
+        )
+      ] })
+    ] }),
+    localError && /* @__PURE__ */ jsx2("div", { class: "error", children: localError }),
+    status === "error" && errorMessage && /* @__PURE__ */ jsx2("div", { class: "error", children: errorMessage }),
+    status === "success" && /* @__PURE__ */ jsx2("div", { class: "success", children: strings["form.success"] }),
+    /* @__PURE__ */ jsxs("div", { class: "actions", children: [
+      /* @__PURE__ */ jsx2("button", { type: "button", class: "btn", onClick: onCancel, disabled: submitting, children: strings["form.cancel"] }),
+      /* @__PURE__ */ jsx2("button", { type: "submit", class: "btn btn--primary", disabled: submitting, children: submitLabel })
+    ] })
+  ] });
+}
+
+// src/widget/Modal.tsx
+import { jsx as jsx3 } from "preact/jsx-runtime";
+function Modal({ onDismiss, children }) {
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      class: "backdrop",
+      role: "presentation",
+      onClick: (e) => {
+        if (e.target === e.currentTarget) onDismiss();
+      },
+      children: /* @__PURE__ */ jsx3("div", { class: "modal", role: "dialog", "aria-modal": "true", children })
+    }
+  );
+}
+
+// src/widget/styles.ts
+var WIDGET_STYLES = `
+:host {
+  --mfb-accent: #3b82f6;
+  --mfb-accent-contrast: #ffffff;
+  --mfb-bg: #ffffff;
+  --mfb-surface: #f9fafb;
+  --mfb-text: #0a0a0a;
+  --mfb-text-muted: #6b7280;
+  --mfb-border: #e5e7eb;
+  --mfb-radius: 8px;
+  --mfb-font: system-ui, -apple-system, sans-serif;
+  --mfb-z-index: 2147483640;
+
+  all: initial;
+  font-family: var(--mfb-font);
+  color: var(--mfb-text);
+  position: fixed;
+  z-index: var(--mfb-z-index);
+}
+
+@media (prefers-color-scheme: dark) {
+  :host {
+    --mfb-bg: #111827;
+    --mfb-surface: #1f2937;
+    --mfb-text: #f9fafb;
+    --mfb-text-muted: #9ca3af;
+    --mfb-border: #374151;
+  }
+}
+
+.fab {
+  position: fixed;
+  bottom: 24px;
+  right: 24px;
+  width: 52px;
+  height: 52px;
+  border-radius: 999px;
+  background: var(--mfb-accent);
+  color: var(--mfb-accent-contrast);
+  border: none;
+  cursor: pointer;
+  box-shadow: 0 4px 14px rgba(0, 0, 0, 0.18);
+  font-size: 22px;
+  display: grid;
+  place-items: center;
+}
+
+.fab:focus-visible { outline: 2px solid var(--mfb-accent); outline-offset: 2px; }
+
+.backdrop {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.45);
+  display: grid;
+  place-items: center;
+}
+
+.modal {
+  background: var(--mfb-bg);
+  border-radius: calc(var(--mfb-radius) * 1.5);
+  box-shadow: 0 20px 48px rgba(0, 0, 0, 0.25);
+  width: min(420px, 92vw);
+  padding: 20px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.modal h2 { margin: 0 0 4px; font-size: 18px; font-weight: 600; }
+
+.field { display: flex; flex-direction: column; gap: 4px; font-size: 13px; }
+
+.field label { color: var(--mfb-text-muted); }
+
+.field input, .field select, .field textarea {
+  font-family: inherit;
+  font-size: 14px;
+  color: inherit;
+  padding: 8px 10px;
+  border: 1px solid var(--mfb-border);
+  border-radius: var(--mfb-radius);
+  background: var(--mfb-surface);
+}
+
+.field textarea { min-height: 88px; resize: vertical; }
+
+.row { display: flex; gap: 8px; }
+.row > * { flex: 1; }
+
+.actions { display: flex; gap: 8px; justify-content: flex-end; padding-top: 8px; }
+
+.btn {
+  padding: 8px 14px;
+  border-radius: var(--mfb-radius);
+  border: 1px solid var(--mfb-border);
+  background: var(--mfb-bg);
+  color: var(--mfb-text);
+  font: inherit;
+  cursor: pointer;
+}
+
+.btn--primary {
+  background: var(--mfb-accent);
+  color: var(--mfb-accent-contrast);
+  border-color: var(--mfb-accent);
+}
+
+.btn[disabled] { opacity: 0.6; cursor: not-allowed; }
+
+.error { color: #dc2626; font-size: 13px; }
+.success { color: #059669; font-size: 13px; }
+`;
+
+// src/widget/mount.tsx
+import { Fragment, jsx as jsx4, jsxs as jsxs2 } from "preact/jsx-runtime";
+function mountWidget(options) {
+  const shadow = options.host.attachShadow({ mode: "open" });
+  const style = document.createElement("style");
+  style.textContent = WIDGET_STYLES;
+  shadow.appendChild(style);
+  const mountPoint = document.createElement("div");
+  shadow.appendChild(mountPoint);
+  let currentState = { open: false, status: "idle" };
+  function rerender(state) {
+    currentState = state;
+    render(h(Root, { state }), mountPoint);
+  }
+  function Root({ state }) {
+    const handleSubmit = useCallback(async (values) => {
+      rerender({ open: true, status: "submitting" });
+      try {
+        await options.onSubmit(values);
+        rerender({ open: true, status: "success" });
+        setTimeout(() => rerender({ open: false, status: "idle" }), 1200);
+      } catch (err) {
+        rerender({ open: true, status: "error", error: err instanceof Error ? err.message : String(err) });
+      }
+    }, []);
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      options.showFAB && /* @__PURE__ */ jsx4(
+        Fab,
+        {
+          label: options.strings["fab.label"],
+          onClick: () => rerender({ ...currentState, open: true })
+        }
+      ),
+      state.open && /* @__PURE__ */ jsx4(Modal, { onDismiss: () => rerender({ open: false, status: "idle" }), children: /* @__PURE__ */ jsx4(
+        Form,
+        {
+          strings: options.strings,
+          onSubmit: handleSubmit,
+          onCancel: () => rerender({ open: false, status: "idle" }),
+          status: state.status,
+          ...state.error !== void 0 && { errorMessage: state.error }
+        }
+      ) })
+    ] });
+  }
+  rerender(currentState);
+  return {
+    open() {
+      rerender({ ...currentState, open: true });
+    },
+    close() {
+      rerender({ ...currentState, open: false, status: "idle" });
+    },
+    dispose() {
+      render(null, mountPoint);
+      options.host.innerHTML = "";
+    }
+  };
+}
+
+// src/core.ts
+function createFeedback(config) {
+  const env = config.env ?? "prod";
+  const strings = resolveStrings(config.translations ?? {});
+  const capture = installCapture({
+    ...config.sanitizeUrl !== void 0 && { sanitizeUrl: config.sanitizeUrl }
+  });
+  const api = createApiClient({
+    apiKey: config.apiKey,
+    ...config.endpoint !== void 0 && { endpoint: config.endpoint },
+    ...config.fetchImpl !== void 0 && { fetch: config.fetchImpl },
+    ...config.beforeSend !== void 0 && { beforeSend: config.beforeSend }
+  });
+  let user = config.user;
+  let metadata = config.metadata ?? {};
+  const transformers = [];
+  const host = document.createElement("div");
+  host.className = "mhosaic-feedback";
+  if (config.attachTo) {
+    const attach = typeof config.attachTo === "string" ? document.querySelector(config.attachTo) : config.attachTo;
+    attach?.appendChild(host);
+  } else {
+    document.body.appendChild(host);
+  }
+  async function buildAndSubmit(values) {
+    const screenshot = await takeScreenshot(document.body, { mask: [".mhosaic-feedback", "[data-mfb-mask]"] });
+    const payload = {
+      description: values.description,
+      feedback_type: values.feedback_type ?? "bug",
+      severity: values.severity ?? "medium",
+      env,
+      page_url: window.location.href,
+      user_agent: navigator.userAgent,
+      capture_method: screenshot ? "html2canvas" : "none",
+      technical_context: capture.snapshot()
+    };
+    if (screenshot) payload.screenshot = screenshot;
+    let finalPayload = payload;
+    for (const t of transformers) finalPayload = await t(finalPayload);
+    try {
+      const result = await api.submitReport(finalPayload);
+      config.onSubmitSuccess?.(result);
+      capture.clear();
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      config.onError?.(error);
+      throw error;
+    }
+  }
+  const handle = mountWidget({
+    host,
+    strings,
+    showFAB: config.showFAB ?? true,
+    onSubmit: async (values) => {
+      await buildAndSubmit(values);
+    }
+  });
+  return {
+    show() {
+      handle.open();
+    },
+    hide() {
+      handle.close();
+    },
+    open(opts) {
+      handle.open();
+      void opts;
+    },
+    async submit(partial) {
+      return buildAndSubmit({
+        description: partial.description,
+        ...partial.feedback_type !== void 0 && { feedback_type: partial.feedback_type },
+        ...partial.severity !== void 0 && { severity: partial.severity }
+      });
+    },
+    identify(u) {
+      user = u;
+      void user;
+    },
+    setMetadata(kv) {
+      metadata = { ...metadata, ...kv };
+      void metadata;
+    },
+    shutdown() {
+      handle.dispose();
+      capture.dispose();
+      host.remove();
+    },
+    _registerTransformer(fn) {
+      transformers.push(fn);
+    }
+  };
+}
+
+export {
+  createFeedback
+};
+//# sourceMappingURL=chunk-RSBFN26C.mjs.map