@clienwork/errors 1.0.0

package/README.md

@@ -0,0 +1,165 @@
+# @clienwork/errors
+
+Clienwork 에러 수집 SDK
+
+## 설치
+
+```bash
+npm install @clienwork/errors
+# or
+yarn add @clienwork/errors
+# or
+pnpm add @clienwork/errors
+```
+
+## 프론트엔드 사용법
+
+### 초기화
+
+```typescript
+import { init } from '@clienwork/errors'
+
+init({
+  apiToken: 'clw_err_xxx', // 프로젝트 설정에서 발급받은 토큰
+  source: 'frontend',      // 기본값
+})
+```
+
+### 수동 에러 리포트
+
+```typescript
+import { report } from '@clienwork/errors'
+
+try {
+  // 위험한 작업
+} catch (error) {
+  report(error, { context: 'checkout' })
+}
+```
+
+### 사용자 식별
+
+```typescript
+import { setUser, clearUser } from '@clienwork/errors'
+
+// 로그인 시
+setUser('user-123')
+
+// 로그아웃 시
+clearUser()
+```
+
+## React 사용법
+
+### Error Boundary
+
+```tsx
+import { ClienworkErrorBoundary } from '@clienwork/errors/react'
+
+function App() {
+  return (
+    <ClienworkErrorBoundary
+      fallback={<div>오류가 발생했습니다.</div>}
+    >
+      <MyComponent />
+    </ClienworkErrorBoundary>
+  )
+}
+```
+
+### useErrorReporter Hook
+
+```tsx
+import { useErrorReporter } from '@clienwork/errors/react'
+
+function MyComponent() {
+  const { report } = useErrorReporter()
+
+  const handleClick = async () => {
+    try {
+      await riskyOperation()
+    } catch (error) {
+      report(error, { action: 'button-click' })
+    }
+  }
+
+  return <button onClick={handleClick}>Click</button>
+}
+```
+
+### HOC
+
+```tsx
+import { withErrorBoundary } from '@clienwork/errors/react'
+
+const SafeComponent = withErrorBoundary(MyComponent, <div>오류 발생</div>)
+```
+
+## 백엔드 사용법 (Node.js)
+
+### 기본 사용법
+
+```typescript
+import { createBackendReporter } from '@clienwork/errors'
+
+const errorReporter = createBackendReporter({
+  apiToken: process.env.CLIENWORK_ERROR_TOKEN!,
+})
+
+try {
+  // 위험한 작업
+} catch (error) {
+  await errorReporter.report(error, { endpoint: '/api/users' })
+}
+```
+
+### Express 미들웨어
+
+```typescript
+import { createBackendReporter, expressErrorHandler } from '@clienwork/errors'
+
+const errorReporter = createBackendReporter({
+  apiToken: process.env.CLIENWORK_ERROR_TOKEN!,
+})
+
+app.use(expressErrorHandler(errorReporter))
+```
+
+### Next.js API Routes
+
+```typescript
+import { createBackendReporter } from '@clienwork/errors'
+
+const errorReporter = createBackendReporter({
+  apiToken: process.env.CLIENWORK_ERROR_TOKEN!,
+})
+
+export async function GET(request: Request) {
+  try {
+    // ...
+  } catch (error) {
+    await errorReporter.report(error as Error)
+    return new Response('Error', { status: 500 })
+  }
+}
+```
+
+## 설정 옵션
+
+```typescript
+init({
+  apiToken: 'clw_err_xxx',     // 필수: API 토큰
+  endpoint: 'https://...',     // 선택: 커스텀 엔드포인트
+  source: 'frontend',          // 선택: 'frontend' | 'backend'
+  enabled: true,               // 선택: 활성화 여부 (개발 환경에서 비활성화 가능)
+  defaultMetadata: {},         // 선택: 모든 에러에 포함될 기본 메타데이터
+  beforeSend: (error) => {     // 선택: 전송 전 에러 수정/필터링
+    // null 반환 시 전송 취소
+    return error
+  },
+})
+```
+
+## 라이선스
+
+MIT

package/dist/chunk-HLDC7IDZ.mjs

@@ -0,0 +1,143 @@
+// src/reporter.ts
+var DEFAULT_ENDPOINT = "https://app.clienwork.com/api/errors";
+var ErrorReporter = class {
+  constructor(config) {
+    this.userId = null;
+    this.metadata = {};
+    this.config = {
+      apiToken: config.apiToken,
+      endpoint: config.endpoint || DEFAULT_ENDPOINT,
+      source: config.source || "frontend",
+      defaultMetadata: config.defaultMetadata || {},
+      enabled: config.enabled ?? true,
+      beforeSend: config.beforeSend
+    };
+    if (typeof window !== "undefined" && this.config.source === "frontend") {
+      this.setupGlobalHandlers();
+    }
+  }
+  setupGlobalHandlers() {
+    window.addEventListener("error", (event) => {
+      this.report({
+        message: event.message,
+        stack: event.error?.stack,
+        url: event.filename,
+        metadata: {
+          lineno: event.lineno,
+          colno: event.colno
+        }
+      });
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+      const error = event.reason;
+      if (error instanceof Error) {
+        this.report(error);
+      } else {
+        this.report({
+          message: String(error),
+          metadata: { type: "unhandledrejection" }
+        });
+      }
+    });
+  }
+  setUser(userId) {
+    this.userId = userId;
+  }
+  clearUser() {
+    this.userId = null;
+  }
+  setMetadata(metadata) {
+    this.metadata = { ...this.metadata, ...metadata };
+  }
+  async report(error, additionalMetadata) {
+    if (!this.config.enabled) return;
+    let reportData;
+    if (error instanceof Error) {
+      reportData = {
+        message: error.message,
+        stack: error.stack,
+        source: this.config.source
+      };
+    } else {
+      reportData = {
+        ...error,
+        source: error.source || this.config.source
+      };
+    }
+    reportData.metadata = {
+      ...this.config.defaultMetadata,
+      ...this.metadata,
+      ...reportData.metadata,
+      ...additionalMetadata
+    };
+    if (this.userId) {
+      reportData.userId = this.userId;
+    }
+    if (typeof window !== "undefined") {
+      reportData.url = reportData.url || window.location.href;
+      reportData.userAgent = reportData.userAgent || navigator.userAgent;
+    }
+    if (this.config.beforeSend) {
+      const modified = this.config.beforeSend(reportData);
+      if (modified === null) return;
+      reportData = modified;
+    }
+    try {
+      await fetch(this.config.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiToken}`
+        },
+        body: JSON.stringify(reportData)
+      });
+    } catch (e) {
+      console.warn("[ClienworkErrors] Failed to report error:", e);
+    }
+  }
+};
+var instance = null;
+function init(config) {
+  instance = new ErrorReporter(config);
+  return instance;
+}
+function getReporter() {
+  return instance;
+}
+function report(error, metadata) {
+  if (!instance) {
+    console.warn("[ClienworkErrors] Not initialized. Call init() first.");
+    return Promise.resolve();
+  }
+  return instance.report(error, metadata);
+}
+function setUser(userId) {
+  instance?.setUser(userId);
+}
+function clearUser() {
+  instance?.clearUser();
+}
+function createBackendReporter(config) {
+  return new ErrorReporter({ ...config, source: "backend" });
+}
+function expressErrorHandler(reporter) {
+  return (err, req, res, next) => {
+    reporter.report(err, {
+      path: req.path,
+      method: req.method,
+      userAgent: req.headers?.["user-agent"]
+    });
+    next();
+  };
+}
+
+export {
+  ErrorReporter,
+  init,
+  getReporter,
+  report,
+  setUser,
+  clearUser,
+  createBackendReporter,
+  expressErrorHandler
+};

package/dist/index.d.mts

@@ -0,0 +1,56 @@
+type ErrorSource = 'frontend' | 'backend';
+type ErrorLevel = 'error' | 'warning';
+interface ErrorReportOptions {
+    message: string;
+    stack?: string;
+    level?: ErrorLevel;
+    source?: ErrorSource;
+    url?: string;
+    userAgent?: string;
+    userId?: string;
+    metadata?: Record<string, unknown>;
+    fingerprint?: string;
+}
+interface ClienworkErrorConfig {
+    apiToken: string;
+    endpoint?: string;
+    source?: ErrorSource;
+    defaultMetadata?: Record<string, unknown>;
+    enabled?: boolean;
+    beforeSend?: (error: ErrorReportOptions) => ErrorReportOptions | null;
+}
+interface ErrorReporterInstance {
+    report: (error: Error | ErrorReportOptions, metadata?: Record<string, unknown>) => Promise<void>;
+    setUser: (userId: string) => void;
+    clearUser: () => void;
+    setMetadata: (metadata: Record<string, unknown>) => void;
+}
+
+declare class ErrorReporter implements ErrorReporterInstance {
+    private config;
+    private userId;
+    private metadata;
+    constructor(config: ClienworkErrorConfig);
+    private setupGlobalHandlers;
+    setUser(userId: string): void;
+    clearUser(): void;
+    setMetadata(metadata: Record<string, unknown>): void;
+    report(error: Error | ErrorReportOptions, additionalMetadata?: Record<string, unknown>): Promise<void>;
+}
+declare function init(config: ClienworkErrorConfig): ErrorReporter;
+declare function getReporter(): ErrorReporter | null;
+declare function report(error: Error | ErrorReportOptions, metadata?: Record<string, unknown>): Promise<void>;
+declare function setUser(userId: string): void;
+declare function clearUser(): void;
+declare function createBackendReporter(config: Omit<ClienworkErrorConfig, 'source'>): ErrorReporter;
+declare function expressErrorHandler(reporter: ErrorReporter): (err: Error, req: {
+    path?: string;
+    method?: string;
+    headers?: Record<string, string>;
+}, res: {
+    status: (code: number) => {
+        json: (data: unknown) => void;
+    };
+}, next: () => void) => void;
+
+export { type ClienworkErrorConfig, type ErrorLevel, type ErrorReportOptions, ErrorReporter, type ErrorReporterInstance, type ErrorSource, clearUser, createBackendReporter, expressErrorHandler, getReporter, init, report, setUser };

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+type ErrorSource = 'frontend' | 'backend';
+type ErrorLevel = 'error' | 'warning';
+interface ErrorReportOptions {
+    message: string;
+    stack?: string;
+    level?: ErrorLevel;
+    source?: ErrorSource;
+    url?: string;
+    userAgent?: string;
+    userId?: string;
+    metadata?: Record<string, unknown>;
+    fingerprint?: string;
+}
+interface ClienworkErrorConfig {
+    apiToken: string;
+    endpoint?: string;
+    source?: ErrorSource;
+    defaultMetadata?: Record<string, unknown>;
+    enabled?: boolean;
+    beforeSend?: (error: ErrorReportOptions) => ErrorReportOptions | null;
+}
+interface ErrorReporterInstance {
+    report: (error: Error | ErrorReportOptions, metadata?: Record<string, unknown>) => Promise<void>;
+    setUser: (userId: string) => void;
+    clearUser: () => void;
+    setMetadata: (metadata: Record<string, unknown>) => void;
+}
+
+declare class ErrorReporter implements ErrorReporterInstance {
+    private config;
+    private userId;
+    private metadata;
+    constructor(config: ClienworkErrorConfig);
+    private setupGlobalHandlers;
+    setUser(userId: string): void;
+    clearUser(): void;
+    setMetadata(metadata: Record<string, unknown>): void;
+    report(error: Error | ErrorReportOptions, additionalMetadata?: Record<string, unknown>): Promise<void>;
+}
+declare function init(config: ClienworkErrorConfig): ErrorReporter;
+declare function getReporter(): ErrorReporter | null;
+declare function report(error: Error | ErrorReportOptions, metadata?: Record<string, unknown>): Promise<void>;
+declare function setUser(userId: string): void;
+declare function clearUser(): void;
+declare function createBackendReporter(config: Omit<ClienworkErrorConfig, 'source'>): ErrorReporter;
+declare function expressErrorHandler(reporter: ErrorReporter): (err: Error, req: {
+    path?: string;
+    method?: string;
+    headers?: Record<string, string>;
+}, res: {
+    status: (code: number) => {
+        json: (data: unknown) => void;
+    };
+}, next: () => void) => void;
+
+export { type ClienworkErrorConfig, type ErrorLevel, type ErrorReportOptions, ErrorReporter, type ErrorReporterInstance, type ErrorSource, clearUser, createBackendReporter, expressErrorHandler, getReporter, init, report, setUser };

package/dist/index.js

@@ -0,0 +1,176 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ErrorReporter: () => ErrorReporter,
+  clearUser: () => clearUser,
+  createBackendReporter: () => createBackendReporter,
+  expressErrorHandler: () => expressErrorHandler,
+  getReporter: () => getReporter,
+  init: () => init,
+  report: () => report,
+  setUser: () => setUser
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/reporter.ts
+var DEFAULT_ENDPOINT = "https://app.clienwork.com/api/errors";
+var ErrorReporter = class {
+  constructor(config) {
+    this.userId = null;
+    this.metadata = {};
+    this.config = {
+      apiToken: config.apiToken,
+      endpoint: config.endpoint || DEFAULT_ENDPOINT,
+      source: config.source || "frontend",
+      defaultMetadata: config.defaultMetadata || {},
+      enabled: config.enabled ?? true,
+      beforeSend: config.beforeSend
+    };
+    if (typeof window !== "undefined" && this.config.source === "frontend") {
+      this.setupGlobalHandlers();
+    }
+  }
+  setupGlobalHandlers() {
+    window.addEventListener("error", (event) => {
+      this.report({
+        message: event.message,
+        stack: event.error?.stack,
+        url: event.filename,
+        metadata: {
+          lineno: event.lineno,
+          colno: event.colno
+        }
+      });
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+      const error = event.reason;
+      if (error instanceof Error) {
+        this.report(error);
+      } else {
+        this.report({
+          message: String(error),
+          metadata: { type: "unhandledrejection" }
+        });
+      }
+    });
+  }
+  setUser(userId) {
+    this.userId = userId;
+  }
+  clearUser() {
+    this.userId = null;
+  }
+  setMetadata(metadata) {
+    this.metadata = { ...this.metadata, ...metadata };
+  }
+  async report(error, additionalMetadata) {
+    if (!this.config.enabled) return;
+    let reportData;
+    if (error instanceof Error) {
+      reportData = {
+        message: error.message,
+        stack: error.stack,
+        source: this.config.source
+      };
+    } else {
+      reportData = {
+        ...error,
+        source: error.source || this.config.source
+      };
+    }
+    reportData.metadata = {
+      ...this.config.defaultMetadata,
+      ...this.metadata,
+      ...reportData.metadata,
+      ...additionalMetadata
+    };
+    if (this.userId) {
+      reportData.userId = this.userId;
+    }
+    if (typeof window !== "undefined") {
+      reportData.url = reportData.url || window.location.href;
+      reportData.userAgent = reportData.userAgent || navigator.userAgent;
+    }
+    if (this.config.beforeSend) {
+      const modified = this.config.beforeSend(reportData);
+      if (modified === null) return;
+      reportData = modified;
+    }
+    try {
+      await fetch(this.config.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiToken}`
+        },
+        body: JSON.stringify(reportData)
+      });
+    } catch (e) {
+      console.warn("[ClienworkErrors] Failed to report error:", e);
+    }
+  }
+};
+var instance = null;
+function init(config) {
+  instance = new ErrorReporter(config);
+  return instance;
+}
+function getReporter() {
+  return instance;
+}
+function report(error, metadata) {
+  if (!instance) {
+    console.warn("[ClienworkErrors] Not initialized. Call init() first.");
+    return Promise.resolve();
+  }
+  return instance.report(error, metadata);
+}
+function setUser(userId) {
+  instance?.setUser(userId);
+}
+function clearUser() {
+  instance?.clearUser();
+}
+function createBackendReporter(config) {
+  return new ErrorReporter({ ...config, source: "backend" });
+}
+function expressErrorHandler(reporter) {
+  return (err, req, res, next) => {
+    reporter.report(err, {
+      path: req.path,
+      method: req.method,
+      userAgent: req.headers?.["user-agent"]
+    });
+    next();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorReporter,
+  clearUser,
+  createBackendReporter,
+  expressErrorHandler,
+  getReporter,
+  init,
+  report,
+  setUser
+});

package/dist/index.mjs

@@ -0,0 +1,20 @@
+import {
+  ErrorReporter,
+  clearUser,
+  createBackendReporter,
+  expressErrorHandler,
+  getReporter,
+  init,
+  report,
+  setUser
+} from "./chunk-HLDC7IDZ.mjs";
+export {
+  ErrorReporter,
+  clearUser,
+  createBackendReporter,
+  expressErrorHandler,
+  getReporter,
+  init,
+  report,
+  setUser
+};

package/dist/react.d.mts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { ErrorReportOptions } from './index.mjs';
+export { ClienworkErrorConfig, clearUser, getReporter, init, report, setUser } from './index.mjs';
+
+interface ErrorBoundaryProps {
+    children: React.ReactNode;
+    fallback?: React.ReactNode | ((error: Error) => React.ReactNode);
+    onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class ClienworkErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+declare function useErrorReporter(): {
+    report: (error: Error | ErrorReportOptions, metadata?: Record<string, unknown>) => Promise<void>;
+};
+declare function withErrorBoundary<P extends object>(Component: React.ComponentType<P>, fallback?: ErrorBoundaryProps['fallback']): React.FC<P>;
+
+export { ClienworkErrorBoundary, ErrorReportOptions, useErrorReporter, withErrorBoundary };

package/dist/react.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { ErrorReportOptions } from './index.js';
+export { ClienworkErrorConfig, clearUser, getReporter, init, report, setUser } from './index.js';
+
+interface ErrorBoundaryProps {
+    children: React.ReactNode;
+    fallback?: React.ReactNode | ((error: Error) => React.ReactNode);
+    onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class ClienworkErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+declare function useErrorReporter(): {
+    report: (error: Error | ErrorReportOptions, metadata?: Record<string, unknown>) => Promise<void>;
+};
+declare function withErrorBoundary<P extends object>(Component: React.ComponentType<P>, fallback?: ErrorBoundaryProps['fallback']): React.FC<P>;
+
+export { ClienworkErrorBoundary, ErrorReportOptions, useErrorReporter, withErrorBoundary };

package/dist/react.js

@@ -0,0 +1,228 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.ts
+var react_exports = {};
+__export(react_exports, {
+  ClienworkErrorBoundary: () => ClienworkErrorBoundary,
+  clearUser: () => clearUser,
+  getReporter: () => getReporter,
+  init: () => init,
+  report: () => report,
+  setUser: () => setUser,
+  useErrorReporter: () => useErrorReporter,
+  withErrorBoundary: () => withErrorBoundary
+});
+module.exports = __toCommonJS(react_exports);
+var React = __toESM(require("react"));
+
+// src/reporter.ts
+var DEFAULT_ENDPOINT = "https://app.clienwork.com/api/errors";
+var ErrorReporter = class {
+  constructor(config) {
+    this.userId = null;
+    this.metadata = {};
+    this.config = {
+      apiToken: config.apiToken,
+      endpoint: config.endpoint || DEFAULT_ENDPOINT,
+      source: config.source || "frontend",
+      defaultMetadata: config.defaultMetadata || {},
+      enabled: config.enabled ?? true,
+      beforeSend: config.beforeSend
+    };
+    if (typeof window !== "undefined" && this.config.source === "frontend") {
+      this.setupGlobalHandlers();
+    }
+  }
+  setupGlobalHandlers() {
+    window.addEventListener("error", (event) => {
+      this.report({
+        message: event.message,
+        stack: event.error?.stack,
+        url: event.filename,
+        metadata: {
+          lineno: event.lineno,
+          colno: event.colno
+        }
+      });
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+      const error = event.reason;
+      if (error instanceof Error) {
+        this.report(error);
+      } else {
+        this.report({
+          message: String(error),
+          metadata: { type: "unhandledrejection" }
+        });
+      }
+    });
+  }
+  setUser(userId) {
+    this.userId = userId;
+  }
+  clearUser() {
+    this.userId = null;
+  }
+  setMetadata(metadata) {
+    this.metadata = { ...this.metadata, ...metadata };
+  }
+  async report(error, additionalMetadata) {
+    if (!this.config.enabled) return;
+    let reportData;
+    if (error instanceof Error) {
+      reportData = {
+        message: error.message,
+        stack: error.stack,
+        source: this.config.source
+      };
+    } else {
+      reportData = {
+        ...error,
+        source: error.source || this.config.source
+      };
+    }
+    reportData.metadata = {
+      ...this.config.defaultMetadata,
+      ...this.metadata,
+      ...reportData.metadata,
+      ...additionalMetadata
+    };
+    if (this.userId) {
+      reportData.userId = this.userId;
+    }
+    if (typeof window !== "undefined") {
+      reportData.url = reportData.url || window.location.href;
+      reportData.userAgent = reportData.userAgent || navigator.userAgent;
+    }
+    if (this.config.beforeSend) {
+      const modified = this.config.beforeSend(reportData);
+      if (modified === null) return;
+      reportData = modified;
+    }
+    try {
+      await fetch(this.config.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiToken}`
+        },
+        body: JSON.stringify(reportData)
+      });
+    } catch (e) {
+      console.warn("[ClienworkErrors] Failed to report error:", e);
+    }
+  }
+};
+var instance = null;
+function init(config) {
+  instance = new ErrorReporter(config);
+  return instance;
+}
+function getReporter() {
+  return instance;
+}
+function report(error, metadata) {
+  if (!instance) {
+    console.warn("[ClienworkErrors] Not initialized. Call init() first.");
+    return Promise.resolve();
+  }
+  return instance.report(error, metadata);
+}
+function setUser(userId) {
+  instance?.setUser(userId);
+}
+function clearUser() {
+  instance?.clearUser();
+}
+
+// src/react.ts
+var ClienworkErrorBoundary = class extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    const reporter = getReporter();
+    if (reporter) {
+      reporter.report(error, {
+        componentStack: errorInfo.componentStack,
+        type: "react-error-boundary"
+      });
+    }
+    this.props.onError?.(error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError && this.state.error) {
+      if (typeof this.props.fallback === "function") {
+        return this.props.fallback(this.state.error);
+      }
+      return this.props.fallback ?? null;
+    }
+    return this.props.children;
+  }
+};
+function useErrorReporter() {
+  const report2 = React.useCallback(
+    (error, metadata) => {
+      const reporter = getReporter();
+      if (reporter) {
+        return reporter.report(error, metadata);
+      }
+      console.warn("[ClienworkErrors] Not initialized. Call init() first.");
+      return Promise.resolve();
+    },
+    []
+  );
+  return { report: report2 };
+}
+function withErrorBoundary(Component2, fallback) {
+  const WrappedComponent = (props) => {
+    return React.createElement(
+      ClienworkErrorBoundary,
+      { fallback, children: React.createElement(Component2, props) }
+    );
+  };
+  WrappedComponent.displayName = `withErrorBoundary(${Component2.displayName || Component2.name || "Component"})`;
+  return WrappedComponent;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClienworkErrorBoundary,
+  clearUser,
+  getReporter,
+  init,
+  report,
+  setUser,
+  useErrorReporter,
+  withErrorBoundary
+});

package/dist/react.mjs

@@ -0,0 +1,72 @@
+import {
+  clearUser,
+  getReporter,
+  init,
+  report,
+  setUser
+} from "./chunk-HLDC7IDZ.mjs";
+
+// src/react.ts
+import * as React from "react";
+var ClienworkErrorBoundary = class extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    const reporter = getReporter();
+    if (reporter) {
+      reporter.report(error, {
+        componentStack: errorInfo.componentStack,
+        type: "react-error-boundary"
+      });
+    }
+    this.props.onError?.(error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError && this.state.error) {
+      if (typeof this.props.fallback === "function") {
+        return this.props.fallback(this.state.error);
+      }
+      return this.props.fallback ?? null;
+    }
+    return this.props.children;
+  }
+};
+function useErrorReporter() {
+  const report2 = React.useCallback(
+    (error, metadata) => {
+      const reporter = getReporter();
+      if (reporter) {
+        return reporter.report(error, metadata);
+      }
+      console.warn("[ClienworkErrors] Not initialized. Call init() first.");
+      return Promise.resolve();
+    },
+    []
+  );
+  return { report: report2 };
+}
+function withErrorBoundary(Component2, fallback) {
+  const WrappedComponent = (props) => {
+    return React.createElement(
+      ClienworkErrorBoundary,
+      { fallback, children: React.createElement(Component2, props) }
+    );
+  };
+  WrappedComponent.displayName = `withErrorBoundary(${Component2.displayName || Component2.name || "Component"})`;
+  return WrappedComponent;
+}
+export {
+  ClienworkErrorBoundary,
+  clearUser,
+  getReporter,
+  init,
+  report,
+  setUser,
+  useErrorReporter,
+  withErrorBoundary
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@clienwork/errors",
+  "version": "1.0.0",
+  "description": "Error collection SDK for Clienwork",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.mjs",
+      "require": "./dist/react.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/react.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts src/react.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "react": "^18.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "error",
+    "tracking",
+    "monitoring",
+    "clienwork"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/clienwork/clienwork"
+  }
+}