@solhun/feedback-kit-core 0.6.1 → 0.8.0

package/dist/index.cjs

@@ -63,8 +63,11 @@ __export(index_exports, {
   PinController: () => PinController,
   RATE_LIMIT_MIN_DELAY_MS: () => RATE_LIMIT_MIN_DELAY_MS,
   REDACTED: () => REDACTED,
+  ROUTE_TRAIL_KEY: () => ROUTE_TRAIL_KEY,
+  ROUTE_TRAIL_LIMIT: () => ROUTE_TRAIL_LIMIT,
   ReportModalController: () => ReportModalController,
   RingBuffer: () => RingBuffer,
+  RouteTrail: () => RouteTrail,
   SCORE_ELEMENT: () => SCORE_ELEMENT,
   SCORE_PATH_EXACT: () => SCORE_PATH_EXACT,
   SCORE_PATH_PATTERN: () => SCORE_PATH_PATTERN,
@@ -100,6 +103,7 @@ __export(index_exports, {
   matchElement: () => matchElement,
   matchPath: () => matchPath,
   normalizePin: () => normalizePin,
+  normalizeRoutePath: () => normalizeRoutePath,
   normalizeUser: () => normalizeUser,
   parseHintCatalog: () => parseHintCatalog,
   parseSourceAttr: () => parseSourceAttr,
@@ -269,6 +273,7 @@ function normalizeDiagnostics(snap) {
   if (!snap || !Array.isArray(snap.network) || !Array.isArray(snap.logs)) {
     return null;
   }
+  if (!Array.isArray(snap.routes)) return { ...snap, routes: [] };
   return snap;
 }
 function safeCall(fn, fallback) {
@@ -743,6 +748,130 @@ var RingBuffer = class {
   }
 };
 
+// src/route-trail.ts
+var ROUTE_TRAIL_LIMIT = 20;
+var ROUTE_TRAIL_KEY = "feedback-kit:route-trail";
+function normalizeRoutePath(route) {
+  const raw = typeof route === "string" ? route : "";
+  const cut = [raw.indexOf("?"), raw.indexOf("#")].filter((i) => i >= 0);
+  const trimmed = (cut.length > 0 ? raw.slice(0, Math.min(...cut)) : raw).trim();
+  return trimmed.length > 0 ? trimmed : "/";
+}
+function parseEntries(raw) {
+  if (!raw) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const out = [];
+  for (const item of parsed) {
+    if (typeof item !== "object" || item === null) continue;
+    const e = item;
+    if (typeof e.to !== "string" || typeof e.at !== "number") continue;
+    out.push({
+      at: e.at,
+      from: typeof e.from === "string" ? e.from : null,
+      to: e.to,
+      count: typeof e.count === "number" && e.count > 0 ? Math.floor(e.count) : 1
+    });
+  }
+  return out;
+}
+var RouteTrail = class {
+  constructor(opts = {}) {
+    this.entries = [];
+    this.unwatch = null;
+    this.limit = opts.limit !== void 0 && opts.limit > 0 ? Math.floor(opts.limit) : ROUTE_TRAIL_LIMIT;
+    this.key = opts.key ?? ROUTE_TRAIL_KEY;
+    this.now = opts.now ?? (() => Date.now());
+    this.storage = opts.storage ?? null;
+    this.restore();
+  }
+  /** 감시자를 붙인다. 이미 붙어 있으면 먼저 끊는다(감시자가 둘이면 이동이 두 번 기록된다). */
+  watch(watcher) {
+    this.unwatchRoutes();
+    try {
+      this.unwatch = watcher((route) => this.record(route));
+    } catch {
+      this.unwatch = null;
+    }
+  }
+  /** 감시자를 뗀다. 버퍼 내용은 그대로 남는다. */
+  unwatchRoutes() {
+    if (!this.unwatch) return;
+    const off = this.unwatch;
+    this.unwatch = null;
+    try {
+      off();
+    } catch {
+    }
+  }
+  /**
+   * 이동 하나를 기록한다.
+   *
+   * 같은 경로로 연속 이동하면 새 줄을 만들지 않고 `count` 만 올린다. 판정은 **직전 항목의
+   * `to`** 와 비교한다 — 새로고침 직후 같은 화면에서 다시 시작해도 줄이 늘지 않는다.
+   */
+  record(route) {
+    const to = normalizeRoutePath(route);
+    const last = this.entries[this.entries.length - 1];
+    if (last && last.to === to) {
+      last.count += 1;
+    } else {
+      this.entries.push({ at: this.now(), from: last ? last.to : null, to, count: 1 });
+      const overflow = this.entries.length - this.limit;
+      if (overflow > 0) this.entries.splice(0, overflow);
+    }
+    this.persist();
+  }
+  /** 지금까지의 궤적. 사본이라 이후 이동이 이미 만든 제보를 바꾸지 않는다. */
+  snapshot() {
+    return this.entries.map((e) => ({ ...e }));
+  }
+  get size() {
+    return this.entries.length;
+  }
+  /** 버퍼와 저장분을 모두 비운다. */
+  clear() {
+    this.entries = [];
+    this.persist();
+  }
+  /** 저장소를 나중에 붙인다. 이미 저장돼 있던 궤적이 있으면 그것을 이어받는다. */
+  attachStorage(storage) {
+    this.storage = storage;
+    if (!storage) return;
+    const restored = parseEntries(this.readRaw());
+    if (restored.length > 0) {
+      this.entries = [...restored, ...this.entries].slice(-this.limit);
+    }
+    this.persist();
+  }
+  // ── 내부: 저장소 ──────────────────────────────────────────
+  // 저장은 **거들 뿐**이다. 던지면 이동 한 번에 앱이 죽는다(프라이빗 모드 등에서
+  // getItem/setItem 이 실제로 던진다). 그래서 전부 삼키고 메모리로 계속 간다.
+  readRaw() {
+    if (!this.storage) return null;
+    try {
+      return this.storage.getItem(this.key);
+    } catch {
+      return null;
+    }
+  }
+  restore() {
+    this.entries = parseEntries(this.readRaw()).slice(-this.limit);
+  }
+  persist() {
+    if (!this.storage) return;
+    try {
+      this.storage.setItem(this.key, JSON.stringify(this.entries));
+    } catch {
+    }
+  }
+};
+
 // src/diagnostics.ts
 var NETWORK_BUFFER_LIMIT = 30;
 var LOG_BUFFER_LIMIT = 50;
@@ -789,6 +918,11 @@ var DiagnosticsCollector = class {
       opts.networkLimit ?? NETWORK_BUFFER_LIMIT
     );
     this.logs = new RingBuffer(opts.logLimit ?? LOG_BUFFER_LIMIT);
+    this.routes = new RouteTrail({
+      limit: opts.routeLimit ?? ROUTE_TRAIL_LIMIT,
+      storage: opts.routeStorage ?? null,
+      now: () => this.now()
+    });
   }
   /** 글로벌 fetch/XHR/console 을 패치한다. 이미 설치했으면 no-op. */
   install(opts = {}) {
@@ -801,6 +935,8 @@ var DiagnosticsCollector = class {
     this.patchFetch();
     this.patchXhr();
     this.patchConsole();
+    if (opts.routeStorage !== void 0) this.routes.attachStorage(opts.routeStorage);
+    if (opts.watchRoutes) this.routes.watch(opts.watchRoutes);
   }
   /** 글로벌 패치를 모두 원복한다. 버퍼 내용은 그대로 남는다. */
   uninstall() {
@@ -827,18 +963,24 @@ var DiagnosticsCollector = class {
     this.originalLog = null;
     this.excludeMatcher = null;
     this.fetchDepth = 0;
+    this.routes.unwatchRoutes();
   }
   /**
    * 지금까지 모인 것을 그대로 스냅샷으로 낸다.
    * 반환 배열은 사본이라 이후 수집이 제보 페이로드를 바꾸지 않는다.
    */
   snapshot() {
-    return { network: this.network.toArray(), logs: this.logs.toArray() };
+    return {
+      network: this.network.toArray(),
+      logs: this.logs.toArray(),
+      routes: this.routes.snapshot()
+    };
   }
-  /** 두 버퍼를 비운다. */
+  /** 세 버퍼를 비운다. */
   clear() {
     this.network.clear();
     this.logs.clear();
+    this.routes.clear();
   }
   // ── 내부: 기록 ────────────────────────────────────────────
   /** 실패 사유 한 줄. 예외 객체엔 요청 본문이 들어 있을 수 있어 메시지만, 길이도 자른다. */
@@ -1243,9 +1385,9 @@ function shouldShowWidget(resolved, input = {}) {
     return false;
   }
 }
-function diagnosticsProviderFor(resolved, collector) {
+function diagnosticsProviderFor(resolved, collector, installOpts) {
   if (!resolved.captureDiagnostics) return void 0;
-  collector.install();
+  collector.install(installOpts);
   return () => collector.snapshot();
 }
 
@@ -1482,7 +1624,7 @@ var ReportModalController = class {
     /** 지금 들고 있는 핀의 기준. 핀이 없으면 의미 없다(기본 `picture`). */
     this.pinAnchor = "picture";
     /**
-     * 사용자가 [제안 ▾] 를 직접 건드렸는가(방향 무관). 한 번이라도 건드리면 이후
+     * 사용자가 [이런 건가요? ▾] 를 직접 건드렸는가(방향 무관). 한 번이라도 건드리면 이후
      * 타이핑에 의한 자동 접힘/펼침이 멈춘다 — "사람이 편 상태는 모달이 닫힐 때까지 유지"를
      * 이렇게 구현한다. `open()` 에서 매번 리셋된다.
      */
@@ -1572,13 +1714,13 @@ var ReportModalController = class {
     this.submitAttempted = false;
     this.pinAnchor = opts.pin && !pendingReport ? "viewport" : "picture";
     this.userToggledHints = false;
-    const resolvedComment = pendingReport?.comment ?? "";
+    const resolvedComment = pendingReport?.comment ?? this.state.comment;
     this.patch({
       open: true,
       comment: resolvedComment,
       // 요소를 지목해서 연 경우엔 그 요소를 물고 간다. 대기 항목 복원이 우선이다.
       element: pendingReport?.element ?? opts.element ?? null,
-      priority: pendingReport?.priority ?? "unset",
+      priority: pendingReport?.priority ?? this.state.priority,
       screenshot: pendingReport?.screenshot ?? null,
       screenshotStatus: "none",
       screenshotMessage: null,
@@ -1615,16 +1757,32 @@ var ReportModalController = class {
   cancelClose() {
     this.patch({ closeConfirmVisible: false });
   }
-  /** 확인 없이 닫는다(요소 지목 모드로 넘어갈 때처럼 흐름이 이어지는 경우). */
+  /**
+   * 확인 없이 닫는다(요소 지목 모드로 넘어갈 때처럼 흐름이 이어지는 경우).
+   *
+   * **쓰던 글은 남긴다.** 지목으로 넘어가는 건 이 제보를 버린 게 아니라 "가리킬 요소를
+   * 고르러 나간" 것이다. 예전엔 여기서 코멘트를 통째로 비웠고, 그래서 모달에 몇 줄 써 놓고
+   * [요소 지목 모드]를 켜면 **확인도 없이 글이 사라졌다** — 사용자가 직접 닫을 때
+   * (`requestClose`)는 확인을 받는데 이 경로만 안 받았다.
+   *
+   * 그림과 좌표는 남기지 않는다. 지목하러 간다는 건 **어느 화면의 무엇을 가리킬지 다시
+   * 정한다**는 뜻이라, 그때의 캡처와 핀은 다음 화면에서 새로 잡는 게 맞다.
+   */
   dismiss() {
-    this.close();
+    this.close({ keepText: true });
   }
+  /**
+   * @param opts.keepResult 전송 결과까지 통째로 보존한다(대기 중 제보 복원용).
+   * @param opts.keepText 사람이 입력한 것(코멘트·우선순위)만 보존한다. 그림·좌표·전송
+   *   상태는 평소처럼 비운다.
+   */
   close(opts) {
     this.captureGeneration += 1;
     const keepDraft = opts?.keepResult || this.state.submitStatus === "pending";
+    const keepText = keepDraft || opts?.keepText === true;
     const cleared = keepDraft ? {} : {
-      comment: "",
-      priority: "unset",
+      comment: keepText ? this.state.comment : "",
+      priority: keepText ? this.state.priority : "unset",
       screenshot: null,
       screenshotStatus: "none",
       screenshotMessage: null,
@@ -1766,7 +1924,7 @@ ${hint.draft}`;
       ...this.hintsPatchFor(comment)
     });
   }
-  /** [제안 ▾] 토글. 방향과 무관하게 이후 자동 접힘/펼침을 멈춘다(`userToggledHints`). */
+  /** [이런 건가요? ▾] 토글. 방향과 무관하게 이후 자동 접힘/펼침을 멈춘다(`userToggledHints`). */
   toggleHints() {
     this.userToggledHints = true;
     this.patch({ hintsExpanded: !this.state.hintsExpanded });
@@ -2379,6 +2537,9 @@ function buildLassoContext(report) {
       device: { ...c.native.device },
       display: { ...c.native.display }
     } : null,
+    // 미수집(진단 자체가 null)과 "이동이 없었음"을 굳이 나누지 않는다 — 둘 다 빈 배열.
+    // 나누려면 서버가 null 을 보존해야 하는데, 그건 확인된 계약이 아니다.
+    routes: [...c.diagnostics?.routes ?? []],
     extra: c.extra
   };
 }
@@ -3043,8 +3204,11 @@ function parseCacheEntry(value) {
   PinController,
   RATE_LIMIT_MIN_DELAY_MS,
   REDACTED,
+  ROUTE_TRAIL_KEY,
+  ROUTE_TRAIL_LIMIT,
   ReportModalController,
   RingBuffer,
+  RouteTrail,
   SCORE_ELEMENT,
   SCORE_PATH_EXACT,
   SCORE_PATH_PATTERN,
@@ -3080,6 +3244,7 @@ function parseCacheEntry(value) {
   matchElement,
   matchPath,
   normalizePin,
+  normalizeRoutePath,
   normalizeUser,
   parseHintCatalog,
   parseSourceAttr,