@lark.js/sentry 0.0.5 → 0.0.7

package/README.md

@@ -0,0 +1,770 @@
+# @lark.js/sentry
+
+`@lark.js/sentry` is a browser monitoring and analytics SDK for page views, declarative clicks, runtime errors, resource errors, HTTP requests, performance metrics, exposure tracking, white-screen detection, offline reporting, and screen record context.
+
+The core entry is framework agnostic. React and Vue integrations are published as dedicated subpath exports so non-framework users do not load framework dependencies.
+
+## Installation
+
+```bash
+npm install @lark.js/sentry
+```
+
+React and Vue are optional peer dependencies. Install them only when the matching integration is used.
+
+```bash
+npm install react
+```
+
+```bash
+npm install vue
+```
+
+## Package Exports
+
+```ts
+import { init, destroy, isInitialized, pluginEnable } from "@lark.js/sentry";
+import { PerformancePlugin, ScreenRecordPlugin, ExposurePlugin } from "@lark.js/sentry/plugins";
+import { ReactErrorBoundary } from "@lark.js/sentry/react";
+import { vuePlugin } from "@lark.js/sentry/vue";
+```
+
+Each public export provides ESM, CJS, and TypeScript declaration files.
+
+## Quick Start
+
+```ts
+import { init, pluginEnable } from "@lark.js/sentry";
+import { PerformancePlugin, ScreenRecordPlugin, ExposurePlugin } from "@lark.js/sentry/plugins";
+
+init({
+  dsn: "/api/log",
+  projectId: "frontend-app",
+  userId: "anonymous",
+});
+
+pluginEnable(PerformancePlugin);
+pluginEnable(ScreenRecordPlugin);
+pluginEnable(ExposurePlugin);
+```
+
+`dsn` must be a non-empty string. If `dsn` is empty, initialization is rejected.
+
+## Lifecycle APIs
+
+### init
+
+`init(options)` validates the input with zod, merges it with default options, writes runtime configuration, installs capture listeners, starts page-view lifecycle tracking, and initializes visitor identity when enabled.
+
+```ts
+import { init } from "@lark.js/sentry";
+
+init({
+  dsn: "/api/log",
+  projectId: "checkout-web",
+  userId: "user-001",
+  enableFetch: true,
+  enableXhr: true,
+  enableClick: true,
+});
+```
+
+### destroy
+
+`destroy()` cleans plugin instances, event subscriptions, browser listeners, and decorated global methods.
+
+```ts
+import { destroy } from "@lark.js/sentry";
+
+destroy();
+```
+
+Use it when resetting tests, unloading a micro-frontend, or dynamically disabling monitoring.
+
+### isInitialized
+
+```ts
+import { init, isInitialized } from "@lark.js/sentry";
+
+if (!isInitialized()) {
+  init({ dsn: "/api/log" });
+}
+```
+
+## Configuration
+
+`init` accepts partial options. Values not provided by the caller use SDK defaults.
+
+| Option                       | Type                   | Default                                             | Description                                            |
+| ---------------------------- | ---------------------- | --------------------------------------------------- | ------------------------------------------------------ |
+| `dsn`                        | `string`               | `""`                                                | Report endpoint. Required for initialization.          |
+| `projectId`                  | `string`               | `"unknown"`                                         | Frontend project identifier.                           |
+| `userId`                     | `string`               | `"unknown"`                                         | Current user identifier.                               |
+| `disabled`                   | `boolean`              | `false`                                             | Disable the SDK.                                       |
+| `enableXhr`                  | `boolean`              | `true`                                              | Capture XMLHttpRequest requests.                       |
+| `enableFetch`                | `boolean`              | `true`                                              | Capture fetch requests.                                |
+| `enableClick`                | `boolean`              | `true`                                              | Capture declarative click events.                      |
+| `enableError`                | `boolean`              | `true`                                              | Capture runtime and resource errors.                   |
+| `enableUnhandledRejection`   | `boolean`              | `true`                                              | Capture unhandled promise rejections.                  |
+| `enableHashChange`           | `boolean`              | `true`                                              | Capture hash navigation.                               |
+| `enableHistory`              | `boolean`              | `true`                                              | Capture history navigation.                            |
+| `enablePerformance`          | `boolean`              | `true`                                              | Enable performance-related capture.                    |
+| `enableScreenRecord`         | `boolean`              | `true`                                              | Enable screen-record-related reporting.                |
+| `enableWhiteScreen`          | `boolean`              | `true`                                              | Enable white-screen detection.                         |
+| `enableFingerprint`          | `boolean`              | `false`                                             | Enable FingerprintJS anonymous visitor identity.       |
+| `anonymousId`                | `string`               | `"unknown"`                                         | SDK-generated anonymous visitor id.                    |
+| `visitorId`                  | `string`               | `"unknown"`                                         | Backend-bound visitor id.                              |
+| `useImageReport`             | `boolean`              | `false`                                             | Allow image transport.                                 |
+| `screenRecordDurationMs`     | `number`               | `3000`                                              | Rolling screen record window length.                   |
+| `screenRecordEventTypes`     | `EventType[]`          | `[Error, Xhr, Fetch, Resource, UnhandledRejection]` | Event types that trigger screen record reporting.      |
+| `hasSkeleton`                | `boolean`              | `false`                                             | Whether the page has a skeleton screen.                |
+| `rootCssSelectors`           | `string[]`             | `["html", "body", "#app", "#root"]`                 | Root selectors used by white-screen detection.         |
+| `clickThrottleDelay`         | `number`               | `0`                                                 | Click capture throttle delay in milliseconds.          |
+| `requestTimeoutMilliseconds` | `number`               | `3000`                                              | Request timeout in milliseconds.                       |
+| `maxBreadcrumbs`             | `number`               | `30`                                                | Breadcrumb capacity.                                   |
+| `repeatCodeError`            | `boolean`              | `false`                                             | Report duplicate code errors.                          |
+| `enableHttpPerformance`      | `boolean`              | `false`                                             | Report successful HTTP requests as performance events. |
+| `ignoreErrors`               | `(string \| RegExp)[]` | `[]`                                                | Runtime error ignore rules.                            |
+| `excludeApis`                | `(string \| RegExp)[]` | `[]`                                                | HTTP request ignore rules.                             |
+| `cacheMaxLength`             | `number`               | `10`                                                | Maximum batch size.                                    |
+| `cacheWaitingTime`           | `number`               | `2000`                                              | Batch wait time in milliseconds.                       |
+| `maxQueueLength`             | `number`               | `200`                                               | Maximum queued events while offline or retrying.       |
+| `retryIntervalMilliseconds`  | `number`               | `60000`                                             | Server recovery probe interval.                        |
+| `offlineCacheKey`            | `string`               | `"lark_sentry_offline_cache"`                       | localStorage key for offline cache.                    |
+| `tracesSampleRate`           | `number`               | `1`                                                 | Sampling rate from 0 to 1.                             |
+| `onBeforePushBreadcrumb`     | `function`             | `undefined`                                         | Hook before storing a breadcrumb.                      |
+| `onBeforeReportData`         | `function`             | `undefined`                                         | Hook before one event enters Reporter queue.           |
+| `beforePushEventList`        | `function`             | `undefined`                                         | Hook before a batch enters transport.                  |
+| `afterSendData`              | `function`             | `undefined`                                         | Hook after a batch enters transport successfully.      |
+| `handleHttpError`            | `function`             | `undefined`                                         | Custom HTTP error callback.                            |
+
+Example production configuration:
+
+```ts
+import { init } from "@lark.js/sentry";
+
+init({
+  dsn: "https://example.com/api/log",
+  projectId: "production-web",
+  userId: "unknown",
+  enableFingerprint: true,
+  enableHttpPerformance: true,
+  tracesSampleRate: 1,
+  excludeApis: ["https://example.com/api/log"],
+  ignoreErrors: [/ResizeObserver loop limit exceeded/],
+});
+```
+
+## Report Data
+
+Reporter sends `IReportData` objects to the configured `dsn`.
+
+| Field        | Description                                |
+| ------------ | ------------------------------------------ |
+| `id`         | Reporter instance id.                      |
+| `type`       | Event type.                                |
+| `name`       | Event name.                                |
+| `message`    | Event message.                             |
+| `status`     | `OK` or `Error`.                           |
+| `time`       | Formatted time.                            |
+| `timestamp`  | Numeric timestamp.                         |
+| `url`        | Current page URL.                          |
+| `userId`     | User identifier.                           |
+| `projectId`  | Project identifier.                        |
+| `sdkVersion` | SDK version.                               |
+| `deviceInfo` | Device, browser, OS, and fingerprint data. |
+| `payload`    | Original event payload.                    |
+
+## Event Types
+
+The SDK can report the following event categories:
+
+| Type                       | Description                     |
+| -------------------------- | ------------------------------- |
+| `XMLHttpRequest`           | XHR request.                    |
+| `fetch`                    | fetch request.                  |
+| `Click`                    | Declarative click.              |
+| `Event hashchange`         | Hash navigation.                |
+| `History`                  | History navigation.             |
+| `Resource`                 | Static resource load failure.   |
+| `Event unhandledrejection` | Unhandled promise rejection.    |
+| `Error`                    | JavaScript runtime error.       |
+| `Vue`                      | Vue error.                      |
+| `React`                    | React error.                    |
+| `Performance`              | Performance metric.             |
+| `ScreenRecord`             | Screen record payload.          |
+| `Exposure`                 | Exposure duration event.        |
+| `WhiteScreen`              | White-screen event.             |
+| `Custom`                   | Custom business event.          |
+| `PV`                       | Page view and dwell-time event. |
+
+## Error Capture
+
+The SDK captures:
+
+- `window` `error` events.
+- Static resource load errors.
+- `console.error` error objects or error text.
+- Unhandled promise rejections.
+- React ErrorBoundary errors.
+- Vue `app.config.errorHandler` errors.
+
+Duplicate code errors are deduplicated by default. Enable duplicate reporting with:
+
+```ts
+init({
+  dsn: "/api/log",
+  repeatCodeError: true,
+});
+```
+
+Ignore known noise:
+
+```ts
+init({
+  dsn: "/api/log",
+  ignoreErrors: ["Script error.", /ResizeObserver loop limit exceeded/],
+});
+```
+
+## HTTP Capture
+
+The SDK decorates `XMLHttpRequest.prototype.open`, `XMLHttpRequest.prototype.send`, and `globalThis.fetch`. It captures method, URL, status code, elapsed time, request data, response data, and `Server-Timing`.
+
+Status classification:
+
+| Status code  | SDK status |
+| ------------ | ---------- |
+| 100 to 399   | `OK`       |
+| 400 to 599   | `Error`    |
+| Other values | `Error`    |
+
+Exclude report endpoints or health checks:
+
+```ts
+init({
+  dsn: "/api/log",
+  excludeApis: ["/api/log", /\/health$/],
+});
+```
+
+Report successful HTTP requests as performance events:
+
+```ts
+init({
+  dsn: "/api/log",
+  enableHttpPerformance: true,
+});
+```
+
+## Page Views and Dwell Time
+
+The SDK reports an initial `PageLoad` PV event during initialization.
+
+On hash or history route changes, it:
+
+- Deduplicates unchanged URLs.
+- Reports `PageDwell` for the previous page.
+- Reports a new PV for the next page.
+- Flushes current dwell time on `beforeunload` when possible.
+
+Dwell time less than or equal to 100 ms is ignored to reduce noise.
+
+Manual page-view reporting:
+
+```ts
+import { tracePageView } from "@lark.js/sentry";
+
+tracePageView({
+  name: "ProductDetail",
+  message: location.href,
+  extra: {
+    productId: "sku-001",
+  },
+});
+```
+
+## Declarative Clicks
+
+Declarative click tracking uses `s-lark-*` attributes. Plain clicks are not reported unless the clicked element or one of its composed path ancestors has a tracking attribute.
+
+```html
+<section s-lark-view="profile-card" s-lark-src="home">
+  <button s-lark-ev="save-profile" s-lark-msg="Save">Save</button>
+</section>
+```
+
+Reserved attributes:
+
+| Attribute     | Description                    |
+| ------------- | ------------------------------ |
+| `s-lark-ev`   | Explicit event ID.             |
+| `s-lark-msg`  | Human-readable message.        |
+| `s-lark-view` | View ID and event ID fallback. |
+
+Custom `s-lark-*` attributes become `params`.
+
+```html
+<a
+  s-lark-ev="open-banner"
+  s-lark-msg="Open campaign banner"
+  s-lark-campaign="spring"
+  s-lark-rank="1"
+>
+  Campaign
+</a>
+```
+
+The reported click payload (`DeclarativeClickData`) includes:
+
+| Field            | Type                                       | Description                                                             |
+| ---------------- | ------------------------------------------ | ----------------------------------------------------------------------- |
+| `ev`             | `string`                                   | Event ID (from `s-lark-ev`, `title`, `s-lark-view`, or tag).            |
+| `msg`            | `string`                                   | Human-readable message (from `s-lark-msg`, text, `aria-label`, or tag). |
+| `triggerPageUrl` | `string`                                   | Current page URL (`location.href`).                                     |
+| `x`              | `number`                                   | Click X coordinate (element offset + scroll offset).                    |
+| `y`              | `number`                                   | Click Y coordinate (element offset + scroll offset).                    |
+| `params`         | `Readonly<Record<string, string \| null>>` | Custom `s-lark-*` attributes (excluding reserved keys).                 |
+| `elementPath`    | `string`                                   | XPath-like path from element to body (max 128 characters).              |
+| `triggerTime`    | `number`                                   | `Date.now()` at click time.                                             |
+
+## White-Screen Detection
+
+White-screen detection samples viewport points after the page is ready and checks whether those points still resolve to configured root elements.
+
+Default root selectors:
+
+```ts
+["html", "body", "#app", "#root"];
+```
+
+```ts
+init({
+  dsn: "/api/log",
+  enableWhiteScreen: true,
+  rootCssSelectors: ["html", "body", "#app"],
+});
+```
+
+Skeleton-screen pages can enable skeleton mode:
+
+```ts
+init({
+  dsn: "/api/log",
+  enableWhiteScreen: true,
+  hasSkeleton: true,
+});
+```
+
+## Visitor Identity
+
+The SDK tracks three identity values:
+
+| Field         | Description                                                         |
+| ------------- | ------------------------------------------------------------------- |
+| `anonymousId` | Anonymous visitor id generated by FingerprintJS and stored locally. |
+| `visitorId`   | Backend-bound visitor id.                                           |
+| `userId`      | Current logged-in user id.                                          |
+
+Enable FingerprintJS:
+
+```ts
+import { getIdentity, init } from "@lark.js/sentry";
+
+init({
+  dsn: "/api/log",
+  enableFingerprint: true,
+});
+
+console.log(getIdentity());
+```
+
+Update user and visitor ids:
+
+```ts
+import { setUserId, setVisitorId } from "@lark.js/sentry";
+
+setUserId("user-001");
+setVisitorId("visitor-001");
+```
+
+Read identity:
+
+```ts
+import { getIdentity } from "@lark.js/sentry";
+
+const identity = getIdentity();
+```
+
+`anonymousId` is stored in localStorage with the key `lark_sentry_anonymous_id`.
+
+## Reporter
+
+Reporter is the unified data outlet. It transforms captured payloads into report data and sends batches to `dsn`.
+
+Reporter behavior:
+
+- Batches events.
+- Applies sampling through `tracesSampleRate`.
+- Persists offline events to localStorage.
+- Flushes cached events after network recovery.
+- Probes server recovery with HEAD requests after failed fetch reports.
+- Avoids concurrent flush races with an `isFlushing` guard.
+- Supports `sendBeacon`, image, and fetch transports.
+
+Transport priority:
+
+1. Use `navigator.sendBeacon` for batches up to 60 KB.
+2. Use image transport when `useImageReport` is true and the batch is up to 2 KB.
+3. Use fetch POST as the fallback.
+
+Flush offline cache manually:
+
+```ts
+import { sendLocal } from "@lark.js/sentry";
+
+await sendLocal();
+```
+
+## Reporter Hooks
+
+Register hooks after initialization or provide equivalent hooks in `init` options.
+
+```ts
+import { afterSendData, beforePushEventList, beforeSendData } from "@lark.js/sentry";
+
+beforeSendData((data) => {
+  if (data.type === "Click") {
+    return false;
+  }
+  return data;
+});
+
+beforePushEventList((eventList) => {
+  return eventList.filter((item) => item.status !== "OK");
+});
+
+afterSendData((eventList) => {
+  console.log("reported", eventList.length);
+});
+```
+
+Equivalent initialization form:
+
+```ts
+init({
+  dsn: "/api/log",
+  onBeforeReportData(data) {
+    return data;
+  },
+  beforePushEventList(eventList) {
+    return eventList;
+  },
+  afterSendData(eventList) {
+    console.log(eventList.length);
+  },
+});
+```
+
+## Manual APIs
+
+### traceError
+
+```ts
+import { traceError } from "@lark.js/sentry";
+
+try {
+  throw new Error("Unexpected state");
+} catch (error) {
+  traceError(error);
+}
+```
+
+### tracePerformance
+
+```ts
+import { tracePerformance } from "@lark.js/sentry";
+
+tracePerformance({
+  name: "SearchLatency",
+  message: "/api/search",
+  value: 128,
+});
+```
+
+### traceCustomEvent
+
+```ts
+import { traceCustomEvent } from "@lark.js/sentry";
+
+traceCustomEvent({
+  name: "CheckoutSuccess",
+  message: "Submit order",
+  extra: {
+    orderId: "order-001",
+  },
+});
+```
+
+### tracePageView
+
+```ts
+import { tracePageView } from "@lark.js/sentry";
+
+tracePageView({
+  name: "ManualPageView",
+  message: location.href,
+});
+```
+
+### getBaseInfo and getUserId
+
+```ts
+import { getBaseInfo, getUserId } from "@lark.js/sentry";
+
+const baseInfo = getBaseInfo();
+const userId = getUserId();
+```
+
+### getIPs
+
+`getIPs` attempts to collect WebRTC ICE candidate IP values in browsers that support the required APIs. It returns an empty array when unsupported.
+
+```ts
+import { getIPs } from "@lark.js/sentry";
+
+const ips = await getIPs();
+```
+
+## Plugin System
+
+Plugins extend the SDK without coupling optional capabilities to the core entry. A plugin class extends `SentryPlugin`, implements `init`, and can implement `destroy` for cleanup.
+
+```ts
+import { pluginEnable } from "@lark.js/sentry";
+import { PerformancePlugin } from "@lark.js/sentry/plugins";
+
+const plugin = pluginEnable(PerformancePlugin);
+```
+
+Enabled plugins are stored in the plugin registry. `destroy()` calls each plugin's `destroy()` method when available.
+
+## PerformancePlugin
+
+```ts
+import { pluginEnable } from "@lark.js/sentry";
+import { PerformancePlugin } from "@lark.js/sentry/plugins";
+
+pluginEnable(PerformancePlugin);
+```
+
+The plugin collects:
+
+- Web Vitals.
+- Navigation Timing page-load metrics.
+- Resource Timing metrics.
+- Long Task entries.
+- Fallback resource-element timing for dynamically inserted resources.
+- `performance.measureUserAgentSpecificMemory` when supported.
+
+Unsupported browser capabilities are skipped safely.
+
+## ScreenRecordPlugin
+
+```ts
+import { pluginEnable } from "@lark.js/sentry";
+import { ScreenRecordPlugin, unzipScreenRecord } from "@lark.js/sentry/plugins";
+
+pluginEnable(ScreenRecordPlugin);
+
+pluginEnable(ScreenRecordPlugin, {
+  durationMs: 5000,
+});
+```
+
+Screen recording is based on rrweb. The plugin keeps a rolling record window. When selected error or network events occur, the recent record window is reported as a `ScreenRecord` event.
+
+Decode a record payload:
+
+```ts
+const events = unzipScreenRecord(recordPayload);
+```
+
+## ExposurePlugin
+
+```ts
+import { pluginEnable } from "@lark.js/sentry";
+import { ExposurePlugin } from "@lark.js/sentry/plugins";
+
+const exposure = pluginEnable(ExposurePlugin);
+```
+
+Observe one element:
+
+```ts
+const element = document.querySelector("#banner");
+
+if (element) {
+  exposure.observe({
+    target: element,
+    threshold: 0.5,
+    params: {
+      bannerId: "spring-001",
+    },
+  });
+}
+```
+
+Observe multiple elements:
+
+```ts
+const first = document.querySelector("#first");
+const second = document.querySelector("#second");
+
+if (first && second) {
+  exposure.observe([
+    {
+      target: first,
+      threshold: 0.5,
+      params: { position: "first" },
+    },
+    {
+      target: second,
+      threshold: 0.75,
+      params: { position: "second" },
+    },
+  ]);
+}
+```
+
+Cancel observation:
+
+```ts
+exposure.unobserve(element);
+exposure.unobserve([first, second]);
+```
+
+Exposure events are reported when an observed element leaves the viewport after becoming visible. The payload contains threshold, observe time, show time, show end time, duration, and user params.
+
+## React Integration
+
+```tsx
+import { init } from "@lark.js/sentry";
+import { ReactErrorBoundary } from "@lark.js/sentry/react";
+
+init({ dsn: "/api/log" });
+
+export function App() {
+  return (
+    <ReactErrorBoundary fallback={<div>Something went wrong</div>}>
+      <Page />
+    </ReactErrorBoundary>
+  );
+}
+```
+
+`fallback` can also be a function:
+
+```tsx
+<ReactErrorBoundary
+  fallback={(error, errorInfo) => (
+    <div>
+      {error.message}
+      {errorInfo.componentStack}
+    </div>
+  )}
+>
+  <Page />
+</ReactErrorBoundary>
+```
+
+The boundary reports `React` events with the error, stack, and React `ErrorInfo`.
+
+## Vue 3 Integration
+
+```ts
+import { createApp } from "vue";
+import { vuePlugin } from "@lark.js/sentry/vue";
+import App from "./app.vue";
+
+const app = createApp(App);
+
+app.use(vuePlugin, {
+  dsn: "/api/log",
+  projectId: "vue-app",
+});
+
+app.mount("#app");
+```
+
+The plugin installs `app.config.errorHandler`, reports `Vue` events, and then calls the previous error handler if one existed.
+
+## Vite Dev-Server Plugin
+
+The SDK provides a Vite plugin that creates a mock report endpoint during development, writing reported data to log files instead of sending it to a real server.
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { sentryPlugin } from "@lark.js/sentry/vite";
+
+export default defineConfig({
+  // `url` should equals to @lark.js/sentry `init({ dsn: "/api/log" })` config `dsn`
+  plugins: [sentryPlugin({ url: "/api/log" })],
+});
+```
+
+### Available Exports
+
+| Export          | Vite Version | Description                             |
+| --------------- | ------------ | --------------------------------------- |
+| `sentryPlugin`  | Vite 6/8     | Default export. For current Vite.       |
+| `sentryPlugin7` | Vite 7       | For projects using Vite 7 specifically. |
+
+### Options
+
+| Option | Type     | Default     | Description                              |
+| ------ | -------- | ----------- | ---------------------------------------- |
+| `url`  | `string` | `"/sentry"` | The URL path to intercept POST requests. |
+
+The plugin creates a `logs/` directory in `process.cwd()`, writes a timestamped log file (`sentry_YYYYMMDDHHMMSS.log`), parses each request body as JSON, and returns `{ code: 0, message: "success" }`.
+
+## Browser Compatibility
+
+- `sendBeacon` is preferred for small batches.
+- Image and fetch transports are used as fallbacks.
+- `PerformanceObserver` powers Web Vitals, long task, and resource timing when available.
+- `MutationObserver` is used as a fallback for dynamically inserted resources.
+- `IntersectionObserver` is required by `ExposurePlugin`.
+- `performance.measureUserAgentSpecificMemory` is optional.
+- `@rrweb/record` is used only by the screen record plugin.
+
+## Quality Gates
+
+```bash
+pnpm exec eslint ./sentry --quiet --ext .js,.jsx,.ts,.tsx
+pnpm --filter @lark.js/sentry typecheck
+pnpm --filter @lark.js/sentry test
+pnpm test:coverage
+pnpm build
+```
+
+Coverage thresholds are 70 for lines, functions, branches, and statements.
+
+## Build and Publish
+
+```bash
+pnpm build
+pnpm build:tsup
+python3 publish.py --dry-run
+```
+
+Publish after npm login:
+
+```bash
+python3 publish.py --publish --registry https://registry.npmjs.org/
+```
+
+The publish script validates lint, typecheck, tests, coverage, build output, ESM imports, CJS requires, package exports, absence of sourcemaps, absence of `dist/node_modules`, and absence of package tarball residue.
+
+Published npm files are limited to `dist` and package metadata. Source files, tests, sourcemaps, and temporary tarballs are not published.

package/dist/package.json.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e="0.0.5",r={version:e};exports.default=r,exports.version=e;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e="0.0.7",r={version:e};exports.default=r,exports.version=e;

package/dist/package.json.js

@@ -1 +1 @@
-var a="0.0.5",e={version:a};export{e as default,a as version};
+var a="0.0.7",e={version:a};export{e as default,a as version};

package/dist/vite.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("node:buffer"),t=require("node:path"),n=require("node:fs");require("./constants/index.cjs"),require("./types/enums.cjs");var r=require("./utils/sentry.cjs"),s=require("./utils/logger.cjs"),i=require("zod");function o(t,n){return"string"==typeof n?t+n:e.Buffer.isBuffer(n)?t+n.toString("utf8"):n instanceof Uint8Array?t+e.Buffer.from(n).toString("utf8"):t}function c(e){return i.z.json().parse(e)}const u=(e,t)=>n=>{n.middlewares.use((n,r,s)=>{if(n.url===e&&"POST"===n.method){let e="";n.on("data",t=>{e=o(e,t)}),n.on("end",()=>{if(e)try{const n=c(e);t.write(JSON.stringify(n)+"\n")}catch{t.write(e+"\n")}r.setHeader("Content-Type","application/json"),r.statusCode=200,r.end(JSON.stringify({code:0,message:"success"}))})}else s()})},a=(e,t)=>n=>{n.middlewares.use((n,r,s)=>{if(n.url===e&&"POST"===n.method){let e="";n.on("data",t=>{e=o(e,t)}),n.on("end",()=>{if(e)try{const n=c(e);t.write(JSON.stringify(n)+"\n")}catch{t.write(e+"\n")}r.setHeader("Content-Type","application/json"),r.statusCode=200,r.end(JSON.stringify({code:0,message:"success"}))})}else s()})};function l({dsn:e}){const s=t.join(process.cwd(),"logs");n.existsSync(s)||n.mkdirSync(s,{recursive:!0});const i=(new Date).toISOString().replace(/[-:.]/g,"").slice(0,14),o=t.join(s,`sentry_${i}.log`),c=n.createWriteStream(o,{flags:"a"});return{name:"vite-plugin-sentry",configureServer:a(e||r.default.options.dsn||"/sentry",c),closeBundle(){c&&c.close()}}}exports.default=l,exports.sentryPlugin=l,exports.sentryPlugin7=function({dsn:e}={}){const i=t.join(process.cwd(),"logs");n.existsSync(i)||n.mkdirSync(i,{recursive:!0});const o=(new Date).toISOString().replace(/[-:.]/g,"").slice(0,14),c=t.join(i,`sentry_${o}.log`),a=n.createWriteStream(c,{flags:"a"});return s.sentryLogger.info("@lark.js/sentry",`Sentry mock plugin initialized, logs will be written to ${c}`),{name:"vite-plugin-sentry",configureServer:u(e||r.default.options.dsn||"/sentry",a),closeBundle(){a&&a.close()}}};
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("node:buffer"),t=require("node:path"),n=require("node:fs");require("./constants/index.cjs"),require("./types/enums.cjs");var r=require("./utils/sentry.cjs"),s=require("./utils/logger.cjs"),i=require("zod");function o(t,n){return"string"==typeof n?t+n:e.Buffer.isBuffer(n)?t+n.toString("utf8"):n instanceof Uint8Array?t+e.Buffer.from(n).toString("utf8"):t}function l(e){return i.z.json().parse(e)}const u=(e,t)=>n=>{n.middlewares.use((n,r,s)=>{if(n.url===e&&"POST"===n.method){let e="";n.on("data",t=>{e=o(e,t)}),n.on("end",()=>{if(e)try{const n=l(e);t.write(JSON.stringify(n)+"\n")}catch{t.write(e+"\n")}r.setHeader("Content-Type","application/json"),r.statusCode=200,r.end(JSON.stringify({code:0,message:"success"}))})}else s()})},c=(e,t)=>n=>{n.middlewares.use((n,r,s)=>{if(n.url===e&&"POST"===n.method){let e="";n.on("data",t=>{e=o(e,t)}),n.on("end",()=>{if(e)try{const n=l(e);t.write(JSON.stringify(n)+"\n")}catch{t.write(e+"\n")}r.setHeader("Content-Type","application/json"),r.statusCode=200,r.end(JSON.stringify({code:0,message:"success"}))})}else s()})};function a(){const e=t.join(process.cwd(),"logs");n.existsSync(e)||n.mkdirSync(e,{recursive:!0});const r=(new Date).toISOString().replace(/[-:.]/g,"").slice(0,14),s=t.join(e,`sentry_${r}.log`);return{fileStream:n.createWriteStream(s,{flags:"a"}),logFile:s}}function f({dsn:e}){const{fileStream:t,logFile:n}=a();return s.sentryLogger.info("@lark.js/sentry",`Sentry mock plugin initialized, logs will be written to ${n}`),{name:"vite-plugin-sentry",configureServer:c(e||r.default.options.dsn||"/sentry",t),closeBundle(){t&&t.close()}}}exports.default=f,exports.sentryPlugin=f,exports.sentryPlugin7=function({dsn:e}={}){const{fileStream:t,logFile:n}=a();return s.sentryLogger.info("@lark.js/sentry",`Sentry mock plugin initialized, logs will be written to ${n}`),{name:"vite-plugin-sentry",configureServer:u(e||r.default.options.dsn||"/sentry",t),closeBundle(){t&&t.close()}}};

package/dist/vite.js

@@ -1 +1 @@
-import{Buffer as e}from"node:buffer";import{join as t}from"node:path";import{existsSync as n,mkdirSync as s,createWriteStream as o}from"node:fs";import"./constants/index.js";import"./types/enums.js";import r from"./utils/sentry.js";import{sentryLogger as i}from"./utils/logger.js";import{z as c}from"zod";function l(t,n){return"string"==typeof n?t+n:e.isBuffer(n)?t+n.toString("utf8"):n instanceof Uint8Array?t+e.from(n).toString("utf8"):t}function a(e){return c.json().parse(e)}const f=(e,t)=>n=>{n.middlewares.use((n,s,o)=>{if(n.url===e&&"POST"===n.method){let e="";n.on("data",t=>{e=l(e,t)}),n.on("end",()=>{if(e)try{const n=a(e);t.write(JSON.stringify(n)+"\n")}catch{t.write(e+"\n")}s.setHeader("Content-Type","application/json"),s.statusCode=200,s.end(JSON.stringify({code:0,message:"success"}))})}else o()})},d=(e,t)=>n=>{n.middlewares.use((n,s,o)=>{if(n.url===e&&"POST"===n.method){let e="";n.on("data",t=>{e=l(e,t)}),n.on("end",()=>{if(e)try{const n=a(e);t.write(JSON.stringify(n)+"\n")}catch{t.write(e+"\n")}s.setHeader("Content-Type","application/json"),s.statusCode=200,s.end(JSON.stringify({code:0,message:"success"}))})}else o()})};function u({dsn:e}={}){const c=t(process.cwd(),"logs");n(c)||s(c,{recursive:!0});const l=(new Date).toISOString().replace(/[-:.]/g,"").slice(0,14),a=t(c,`sentry_${l}.log`),d=o(a,{flags:"a"});return i.info("@lark.js/sentry",`Sentry mock plugin initialized, logs will be written to ${a}`),{name:"vite-plugin-sentry",configureServer:f(e||r.options.dsn||"/sentry",d),closeBundle(){d&&d.close()}}}function p({dsn:e}){const i=t(process.cwd(),"logs");n(i)||s(i,{recursive:!0});const c=(new Date).toISOString().replace(/[-:.]/g,"").slice(0,14),l=t(i,`sentry_${c}.log`),a=o(l,{flags:"a"});return{name:"vite-plugin-sentry",configureServer:d(e||r.options.dsn||"/sentry",a),closeBundle(){a&&a.close()}}}export{p as default,p as sentryPlugin,u as sentryPlugin7};
+import{Buffer as e}from"node:buffer";import{join as t}from"node:path";import{existsSync as n,mkdirSync as o,createWriteStream as s}from"node:fs";import"./constants/index.js";import"./types/enums.js";import r from"./utils/sentry.js";import{sentryLogger as i}from"./utils/logger.js";import{z as l}from"zod";function c(t,n){return"string"==typeof n?t+n:e.isBuffer(n)?t+n.toString("utf8"):n instanceof Uint8Array?t+e.from(n).toString("utf8"):t}function a(e){return l.json().parse(e)}const f=(e,t)=>n=>{n.middlewares.use((n,o,s)=>{if(n.url===e&&"POST"===n.method){let e="";n.on("data",t=>{e=c(e,t)}),n.on("end",()=>{if(e)try{const n=a(e);t.write(JSON.stringify(n)+"\n")}catch{t.write(e+"\n")}o.setHeader("Content-Type","application/json"),o.statusCode=200,o.end(JSON.stringify({code:0,message:"success"}))})}else s()})},u=(e,t)=>n=>{n.middlewares.use((n,o,s)=>{if(n.url===e&&"POST"===n.method){let e="";n.on("data",t=>{e=c(e,t)}),n.on("end",()=>{if(e)try{const n=a(e);t.write(JSON.stringify(n)+"\n")}catch{t.write(e+"\n")}o.setHeader("Content-Type","application/json"),o.statusCode=200,o.end(JSON.stringify({code:0,message:"success"}))})}else s()})};function d(){const e=t(process.cwd(),"logs");n(e)||o(e,{recursive:!0});const r=(new Date).toISOString().replace(/[-:.]/g,"").slice(0,14),i=t(e,`sentry_${r}.log`);return{fileStream:s(i,{flags:"a"}),logFile:i}}function m({dsn:e}={}){const{fileStream:t,logFile:n}=d();return i.info("@lark.js/sentry",`Sentry mock plugin initialized, logs will be written to ${n}`),{name:"vite-plugin-sentry",configureServer:f(e||r.options.dsn||"/sentry",t),closeBundle(){t&&t.close()}}}function g({dsn:e}){const{fileStream:t,logFile:n}=d();return i.info("@lark.js/sentry",`Sentry mock plugin initialized, logs will be written to ${n}`),{name:"vite-plugin-sentry",configureServer:u(e||r.options.dsn||"/sentry",t),closeBundle(){t&&t.close()}}}export{g as default,g as sentryPlugin,m as sentryPlugin7};

package/dist/webpack.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("node:buffer"),t=require("node:path"),r=require("node:fs"),n=require("zod");require("./constants/index.cjs"),require("./types/enums.cjs");var s=require("./utils/sentry.cjs"),i=require("./utils/logger.cjs");function o(t,r){return(s,i,o)=>{if(s.url===t&&"POST"===s.method){let t="";s.on("data",r=>{t=function(t,r){return"string"==typeof r?t+r:e.Buffer.isBuffer(r)?t+r.toString("utf8"):r instanceof Uint8Array?t+e.Buffer.from(r).toString("utf8"):t}(t,r)}),s.on("end",()=>{if(t)try{const e=function(e){return n.z.json().parse(e)}(t);r.write(JSON.stringify(e)+"\n")}catch{r.write(t+"\n")}i.setHeader("Content-Type","application/json"),i.statusCode=200,i.end(JSON.stringify({code:0,message:"success"}))})}else o()}}function u(){const e=t.join(process.cwd(),"logs");r.existsSync(e)||r.mkdirSync(e,{recursive:!0});const n=(new Date).toISOString().replace(/[-:.]/g,"").slice(0,14),s=t.join(e,`sentry_${n}.log`);return{fileStream:r.createWriteStream(s,{flags:"a"}),logFile:s}}class l{dsn;constructor(e={}){this.dsn=e.dsn}apply(e){const t=e.options.devServer,{fileStream:r,logFile:n}=u(),l=o(this.dsn||s.default.options.dsn||"/sentry",r);i.sentryLogger.info("@lark.js/sentry",`Sentry mock plugin initialized, logs will be written to ${n}`);const c=t.setupMiddlewares;t.setupMiddlewares=(e,t)=>{const r=c?c(e,t):e,n={name:"sentry-mock",middleware:l};return r.unshift(n),r},e.hooks.shutdown.tap("SentryWebpackPlugin",()=>{r&&!r.destroyed&&r.close()})}}function c(e={}){return new l(e)}exports.SentryWebpackPlugin=l,exports.default=c,exports.sentryMiddleware=function(e={}){const{fileStream:t,logFile:r}=u();return i.sentryLogger.info("@lark.js/sentry",`Sentry mock middleware initialized, logs will be written to ${r}`),o(e.dsn||s.default.options.dsn||"/sentry",t)},exports.sentryPlugin=c;

package/dist/webpack.d.ts

@@ -0,0 +1,55 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { WebpackPluginInstance, Compiler } from 'webpack';
+import DevServer from 'webpack-dev-server';
+
+type SentryDevMiddleware = (req: IncomingMessage, res: ServerResponse, next: DevServer.NextFunction) => void;
+interface ISentryWebpackPluginOptions {
+    dsn?: string;
+}
+/**
+ * Connect/express-style middleware that mocks the sentry report endpoint
+ * during webpack-dev-server development. Mount it manually inside the
+ * `setupMiddlewares` option of webpack-dev-server.
+ *
+ * @example
+ * ```ts
+ * import { sentryMiddleware } from "@lark.js/sentry/webpack";
+ *
+ * export default {
+ *   devServer: {
+ *     setupMiddlewares(middlewares) {
+ *       middlewares.unshift({
+ *         name: "sentry-mock",
+ *         middleware: sentryMiddleware({ dsn: "/api/log" }),
+ *       });
+ *       return middlewares;
+ *     },
+ *   },
+ * };
+ * ```
+ */
+declare function sentryMiddleware(options?: ISentryWebpackPluginOptions): SentryDevMiddleware;
+/**
+ * Webpack plugin that automatically wires the sentry log-collection middleware
+ * into webpack-dev-server. It only takes effect when
+ * `compiler.options.devServer` exists, so production builds remain untouched.
+ *
+ * @example
+ * ```ts
+ * import { sentryPlugin } from "@lark.js/sentry/webpack";
+ *
+ * export default {
+ *   plugins: [sentryPlugin({ dsn: "/api/log" })],
+ *   devServer: { ... },
+ * };
+ * ```
+ */
+declare class SentryWebpackPlugin implements WebpackPluginInstance {
+    private readonly dsn;
+    constructor(options?: ISentryWebpackPluginOptions);
+    apply(compiler: Compiler): void;
+}
+declare function sentryPlugin(options?: ISentryWebpackPluginOptions): SentryWebpackPlugin;
+
+export { SentryWebpackPlugin, sentryPlugin as default, sentryMiddleware, sentryPlugin };
+export type { ISentryWebpackPluginOptions, SentryDevMiddleware };

package/dist/webpack.js

@@ -0,0 +1 @@
+import{Buffer as t}from"node:buffer";import{join as e}from"node:path";import{existsSync as n,mkdirSync as o,createWriteStream as r}from"node:fs";import{z as s}from"zod";import"./constants/index.js";import"./types/enums.js";import i from"./utils/sentry.js";import{sentryLogger as l}from"./utils/logger.js";function a(e,n){return(o,r,i)=>{if(o.url===e&&"POST"===o.method){let e="";o.on("data",n=>{e=function(e,n){return"string"==typeof n?e+n:t.isBuffer(n)?e+n.toString("utf8"):n instanceof Uint8Array?e+t.from(n).toString("utf8"):e}(e,n)}),o.on("end",()=>{if(e)try{const t=function(t){return s.json().parse(t)}(e);n.write(JSON.stringify(t)+"\n")}catch{n.write(e+"\n")}r.setHeader("Content-Type","application/json"),r.statusCode=200,r.end(JSON.stringify({code:0,message:"success"}))})}else i()}}function d(){const t=e(process.cwd(),"logs");n(t)||o(t,{recursive:!0});const s=(new Date).toISOString().replace(/[-:.]/g,"").slice(0,14),i=e(t,`sentry_${s}.log`);return{fileStream:r(i,{flags:"a"}),logFile:i}}function c(t={}){const{fileStream:e,logFile:n}=d();l.info("@lark.js/sentry",`Sentry mock middleware initialized, logs will be written to ${n}`);return a(t.dsn||i.options.dsn||"/sentry",e)}class f{dsn;constructor(t={}){this.dsn=t.dsn}apply(t){const e=t.options.devServer,{fileStream:n,logFile:o}=d(),r=a(this.dsn||i.options.dsn||"/sentry",n);l.info("@lark.js/sentry",`Sentry mock plugin initialized, logs will be written to ${o}`);const s=e.setupMiddlewares;e.setupMiddlewares=(t,e)=>{const n=s?s(t,e):t,o={name:"sentry-mock",middleware:r};return n.unshift(o),n},t.hooks.shutdown.tap("SentryWebpackPlugin",()=>{n&&!n.destroyed&&n.close()})}}function u(t={}){return new f(t)}export{f as SentryWebpackPlugin,u as default,c as sentryMiddleware,u as sentryPlugin};

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@lark.js/sentry",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "sentry sdk",
-  "type": "module",
   "keywords": [
-    "sentry",
-    "sdk"
+    "sdk",
+    "sentry"
   ],
-  "author": "github.com/hangtiancheng",
   "license": "MIT",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "author": "github.com/hangtiancheng",
   "files": [
     "dist",
-    "../README.md"
+    "README.md"
   ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -41,6 +41,11 @@
       "types": "./dist/vite.d.ts",
       "import": "./dist/vite.js",
       "require": "./dist/vite.cjs"
+    },
+    "./webpack": {
+      "types": "./dist/webpack.d.ts",
+      "import": "./dist/webpack.js",
+      "require": "./dist/webpack.cjs"
     }
   },
   "scripts": {
@@ -48,7 +53,8 @@
     "test:watch": "vitest --config ./vitest.config.ts",
     "test:coverage": "vitest run --config ./vitest.config.ts --coverage",
     "typecheck": "tsc --noEmit",
-    "vite7": "pnpm add -D vite7@npm:vite@7.3.3"
+    "vite7": "pnpm add -D vite7@npm:vite@7.3.3",
+    "format": "oxfmt --write ./"
   },
   "dependencies": {
     "@fingerprintjs/fingerprintjs": "^5.2.0",
@@ -63,24 +69,28 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
     "@rrweb/record": "2.0.0-alpha.20",
-    "@types/node": "^25.9.1",
+    "@types/node": "^25.9.2",
     "@types/pako": "^2.0.4",
-    "@types/react": "^19.2.15",
+    "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "@vitest/coverage-v8": "^1.6.1",
     "jsdom": "^24.1.3",
-    "react": "^19.2.6",
-    "rollup": "^4.61.0",
+    "oxfmt": "^0.54.0",
+    "react": "^19.2.7",
+    "rollup": "^4.61.1",
     "typescript": "^6.0.3",
     "vite": "^8.0.16",
     "vite7": "npm:vite@7.3.3",
     "vitest": "^1.6.1",
-    "vue": "^3.5.35"
+    "vue": "^3.5.35",
+    "webpack": "^5.107.2",
+    "webpack-dev-server": "^5.2.4"
   },
   "peerDependencies": {
     "react": "^19.0.0",
     "vite": "^7.0.0 || ^8.0.0",
-    "vue": "^3.0.0"
+    "vue": "^3.0.0",
+    "webpack": "^4.0.0 || ^5.0.0"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -91,6 +101,12 @@
     },
     "vue": {
       "optional": true
+    },
+    "webpack": {
+      "optional": true
+    },
+    "webpack-dev-server": {
+      "optional": true
     }
   }
 }