@mdxui/do 2.1.1 → 3.0.0

package/dist/chunk-5AWTQDRF.js

@@ -0,0 +1,76 @@
+// src/lib/errors.ts
+var APIError = class _APIError extends Error {
+  constructor(code, message, status, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "APIError";
+    Object.setPrototypeOf(this, _APIError.prototype);
+  }
+  /**
+   * Create an APIError from a fetch Response
+   *
+   * @param response - The Response object from fetch
+   * @param body - Optional response body text (if already read)
+   * @returns An APIError with HTTP status information
+   *
+   * @example
+   * ```typescript
+   * const response = await fetch('/api/things')
+   * if (!response.ok) {
+   *   throw APIError.fromResponse(response, await response.text())
+   * }
+   * ```
+   */
+  static fromResponse(response, body) {
+    return new _APIError(`HTTP_${response.status}`, body || response.statusText, response.status);
+  }
+  /**
+   * Type guard to check if an error is an APIError
+   */
+  static isAPIError(error) {
+    return error instanceof _APIError;
+  }
+};
+var NetworkError = class _NetworkError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends Error {
+  constructor(message, fields) {
+    super(message);
+    this.fields = fields;
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var SyncError = class _SyncError extends Error {
+  constructor(message, operation, recoverable) {
+    super(message);
+    this.operation = operation;
+    this.recoverable = recoverable;
+    this.name = "SyncError";
+    Object.setPrototypeOf(this, _SyncError.prototype);
+  }
+};
+function isAPIError(error) {
+  return error instanceof APIError;
+}
+function isNetworkError(error) {
+  return error instanceof NetworkError;
+}
+function isValidationError(error) {
+  return error instanceof ValidationError;
+}
+function isSyncError(error) {
+  return error instanceof SyncError;
+}
+
+export { APIError, NetworkError, SyncError, ValidationError, isAPIError, isNetworkError, isSyncError, isValidationError };
+//# sourceMappingURL=chunk-5AWTQDRF.js.map
+//# sourceMappingURL=chunk-5AWTQDRF.js.map

package/dist/chunk-5AWTQDRF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/errors.ts"],"names":[],"mappings":";AAwCO,IAAM,QAAA,GAAN,MAAM,SAAA,SAAiB,KAAA,CAAM;AAAA,EAClC,WAAA,CACkB,IAAA,EAChB,OAAA,EACgB,MAAA,EACA,OAAA,EAChB;AACA,IAAA,KAAA,CAAM,OAAO,CAAA;AALG,IAAA,IAAA,CAAA,IAAA,GAAA,IAAA;AAEA,IAAA,IAAA,CAAA,MAAA,GAAA,MAAA;AACA,IAAA,IAAA,CAAA,OAAA,GAAA,OAAA;AAGhB,IAAA,IAAA,CAAK,IAAA,GAAO,UAAA;AAEZ,IAAA,MAAA,CAAO,cAAA,CAAe,IAAA,EAAM,SAAA,CAAS,SAAS,CAAA;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,OAAO,YAAA,CAAa,QAAA,EAAoB,IAAA,EAAyB;AAC/D,IAAA,OAAO,IAAI,SAAA,CAAS,CAAA,KAAA,EAAQ,QAAA,CAAS,MAAM,IAAI,IAAA,IAAQ,QAAA,CAAS,UAAA,EAAY,QAAA,CAAS,MAAM,CAAA;AAAA,EAC7F;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,WAAW,KAAA,EAAmC;AACnD,IAAA,OAAO,KAAA,YAAiB,SAAA;AAAA,EAC1B;AACF;AAWO,IAAM,YAAA,GAAN,MAAM,aAAA,SAAqB,KAAA,CAAM;AAAA,EACtC,WAAA,CACE,SACgB,KAAA,EAChB;AACA,IAAA,KAAA,CAAM,OAAO,CAAA;AAFG,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAGhB,IAAA,IAAA,CAAK,IAAA,GAAO,cAAA;AACZ,IAAA,MAAA,CAAO,cAAA,CAAe,IAAA,EAAM,aAAA,CAAa,SAAS,CAAA;AAAA,EACpD;AACF;AAgBO,IAAM,eAAA,GAAN,MAAM,gBAAA,SAAwB,KAAA,CAAM;AAAA,EACzC,WAAA,CACE,SACgB,MAAA,EAChB;AACA,IAAA,KAAA,CAAM,OAAO,CAAA;AAFG,IAAA,IAAA,CAAA,MAAA,GAAA,MAAA;AAGhB,IAAA,IAAA,CAAK,IAAA,GAAO,iBAAA;AACZ,IAAA,MAAA,CAAO,cAAA,CAAe,IAAA,EAAM,gBAAA,CAAgB,SAAS,CAAA;AAAA,EACvD;AACF;AAkBO,IAAM,SAAA,GAAN,MAAM,UAAA,SAAkB,KAAA,CAAM;AAAA,EACnC,WAAA,CACE,OAAA,EACgB,SAAA,EACA,WAAA,EAChB;AACA,IAAA,KAAA,CAAM,OAAO,CAAA;AAHG,IAAA,IAAA,CAAA,SAAA,GAAA,SAAA;AACA,IAAA,IAAA,CAAA,WAAA,GAAA,WAAA;AAGhB,IAAA,IAAA,CAAK,IAAA,GAAO,WAAA;AACZ,IAAA,MAAA,CAAO,cAAA,CAAe,IAAA,EAAM,UAAA,CAAU,SAAS,CAAA;AAAA,EACjD;AACF;AAKO,SAAS,WAAW,KAAA,EAAmC;AAC5D,EAAA,OAAO,KAAA,YAAiB,QAAA;AAC1B;AAKO,SAAS,eAAe,KAAA,EAAuC;AACpE,EAAA,OAAO,KAAA,YAAiB,YAAA;AAC1B;AAKO,SAAS,kBAAkB,KAAA,EAA0C;AAC1E,EAAA,OAAO,KAAA,YAAiB,eAAA;AAC1B;AAKO,SAAS,YAAY,KAAA,EAAoC;AAC9D,EAAA,OAAO,KAAA,YAAiB,SAAA;AAC1B","file":"chunk-5AWTQDRF.js","sourcesContent":["/**\n * Standardized error classes for @mdxui/do\n *\n * These classes provide consistent error handling across the package:\n * - APIError: HTTP/RPC errors from the backend\n * - NetworkError: Connection/fetch failures\n * - ValidationError: Input validation errors\n * - SyncError: Real-time sync errors\n *\n * @example\n * ```typescript\n * import { APIError, NetworkError, isAPIError } from '@mdxui/do'\n *\n * try {\n *   const response = await fetch(url)\n *   if (!response.ok) {\n *     throw APIError.fromResponse(response)\n *   }\n * } catch (error) {\n *   if (isAPIError(error)) {\n *     console.log(`API error ${error.code}: ${error.message}`)\n *     if (error.status === 401) {\n *       // Handle auth error\n *     }\n *   } else if (isNetworkError(error)) {\n *     console.log('Network unavailable, will retry...')\n *   }\n * }\n * ```\n */\n\n/**\n * API error from HTTP/RPC calls\n *\n * Provides structured error information including:\n * - code: Machine-readable error code (e.g., 'HTTP_404', 'VALIDATION_ERROR')\n * - message: Human-readable error message\n * - status: HTTP status code (when applicable)\n * - details: Additional error details from the server\n */\nexport class APIError extends Error {\n  constructor(\n    public readonly code: string,\n    message: string,\n    public readonly status?: number,\n    public readonly details?: Record<string, unknown>\n  ) {\n    super(message)\n    this.name = 'APIError'\n    // Maintain proper prototype chain for instanceof checks\n    Object.setPrototypeOf(this, APIError.prototype)\n  }\n\n  /**\n   * Create an APIError from a fetch Response\n   *\n   * @param response - The Response object from fetch\n   * @param body - Optional response body text (if already read)\n   * @returns An APIError with HTTP status information\n   *\n   * @example\n   * ```typescript\n   * const response = await fetch('/api/things')\n   * if (!response.ok) {\n   *   throw APIError.fromResponse(response, await response.text())\n   * }\n   * ```\n   */\n  static fromResponse(response: Response, body?: string): APIError {\n    return new APIError(`HTTP_${response.status}`, body || response.statusText, response.status)\n  }\n\n  /**\n   * Type guard to check if an error is an APIError\n   */\n  static isAPIError(error: unknown): error is APIError {\n    return error instanceof APIError\n  }\n}\n\n/**\n * Network-level error (connection failures, timeouts, etc.)\n *\n * Use for errors that occur before an HTTP response is received:\n * - DNS resolution failures\n * - Connection refused\n * - Request timeouts\n * - CORS errors\n */\nexport class NetworkError extends Error {\n  constructor(\n    message: string,\n    public readonly cause?: Error\n  ) {\n    super(message)\n    this.name = 'NetworkError'\n    Object.setPrototypeOf(this, NetworkError.prototype)\n  }\n}\n\n/**\n * Validation error with field-level details\n *\n * Use when input data fails validation checks.\n * The fields property maps field names to arrays of error messages.\n *\n * @example\n * ```typescript\n * throw new ValidationError('Invalid input', {\n *   email: ['Invalid email format'],\n *   name: ['Name is required', 'Name must be at least 2 characters'],\n * })\n * ```\n */\nexport class ValidationError extends Error {\n  constructor(\n    message: string,\n    public readonly fields: Record<string, string[]>\n  ) {\n    super(message)\n    this.name = 'ValidationError'\n    Object.setPrototypeOf(this, ValidationError.prototype)\n  }\n}\n\n/**\n * Real-time sync error\n *\n * Use for errors in the sync protocol (WebSocket, EventSource, etc.).\n * The operation property indicates what sync operation failed.\n * The recoverable property indicates whether the client should retry.\n *\n * @example\n * ```typescript\n * // Recoverable connection error - client should retry\n * throw new SyncError('WebSocket disconnected', 'connect', true)\n *\n * // Non-recoverable push error - user intervention needed\n * throw new SyncError('Conflict: record modified by another user', 'push', false)\n * ```\n */\nexport class SyncError extends Error {\n  constructor(\n    message: string,\n    public readonly operation: 'push' | 'pull' | 'connect',\n    public readonly recoverable: boolean\n  ) {\n    super(message)\n    this.name = 'SyncError'\n    Object.setPrototypeOf(this, SyncError.prototype)\n  }\n}\n\n/**\n * Type guard to check if an error is an APIError\n */\nexport function isAPIError(error: unknown): error is APIError {\n  return error instanceof APIError\n}\n\n/**\n * Type guard to check if an error is a NetworkError\n */\nexport function isNetworkError(error: unknown): error is NetworkError {\n  return error instanceof NetworkError\n}\n\n/**\n * Type guard to check if an error is a ValidationError\n */\nexport function isValidationError(error: unknown): error is ValidationError {\n  return error instanceof ValidationError\n}\n\n/**\n * Type guard to check if an error is a SyncError\n */\nexport function isSyncError(error: unknown): error is SyncError {\n  return error instanceof SyncError\n}\n"]}

package/dist/chunk-EQVOEEQO.js

@@ -0,0 +1,95 @@
+import { cn } from './chunk-Y52IEYVM.js';
+import * as React from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var DOErrorBoundary = class extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("DOErrorBoundary caught error:", error, errorInfo);
+    if (this.props.onError) {
+      this.props.onError(error, errorInfo);
+    }
+  }
+  componentDidUpdate(prevProps) {
+    if (this.state.hasError && prevProps.resetKey !== this.props.resetKey) {
+      this.reset();
+    }
+  }
+  reset = () => {
+    this.setState({ hasError: false, error: null });
+  };
+  render() {
+    if (this.state.hasError) {
+      const { fallback, className } = this.props;
+      const error = this.state.error ?? new Error("Unknown error");
+      if (typeof fallback === "function") {
+        return fallback(error, this.reset);
+      }
+      if (fallback) {
+        return fallback;
+      }
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: cn(
+            "p-6 rounded-lg bg-destructive/10 border border-destructive/20",
+            className
+          ),
+          role: "alert",
+          children: /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-3", children: [
+            /* @__PURE__ */ jsx("div", { className: "flex-shrink-0 mt-0.5", children: /* @__PURE__ */ jsx(
+              "svg",
+              {
+                className: "h-5 w-5 text-destructive",
+                viewBox: "0 0 20 20",
+                fill: "currentColor",
+                "aria-hidden": "true",
+                children: /* @__PURE__ */ jsx(
+                  "path",
+                  {
+                    fillRule: "evenodd",
+                    d: "M10 18a8 8 0 100-16 8 8 0 000 16zM8.28 7.22a.75.75 0 00-1.06 1.06L8.94 10l-1.72 1.72a.75.75 0 101.06 1.06L10 11.06l1.72 1.72a.75.75 0 101.06-1.06L11.06 10l1.72-1.72a.75.75 0 00-1.06-1.06L10 8.94 8.28 7.22z",
+                    clipRule: "evenodd"
+                  }
+                )
+              }
+            ) }),
+            /* @__PURE__ */ jsxs("div", { className: "flex-1", children: [
+              /* @__PURE__ */ jsx("h2", { className: "text-sm font-semibold text-destructive", children: "Something went wrong" }),
+              error.message && /* @__PURE__ */ jsx("p", { className: "mt-1 text-sm text-muted-foreground", children: error.message }),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  onClick: this.reset,
+                  className: "mt-4 inline-flex items-center rounded-md bg-destructive px-3 py-2 text-sm font-semibold text-destructive-foreground shadow-sm hover:bg-destructive/90 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-destructive",
+                  children: "Try again"
+                }
+              )
+            ] })
+          ] })
+        }
+      );
+    }
+    return this.props.children;
+  }
+};
+function useErrorBoundary() {
+  const [error, setError] = React.useState(null);
+  if (error) {
+    throw error;
+  }
+  return {
+    showBoundary: setError
+  };
+}
+
+export { DOErrorBoundary, useErrorBoundary };
+//# sourceMappingURL=chunk-EQVOEEQO.js.map
+//# sourceMappingURL=chunk-EQVOEEQO.js.map

package/dist/chunk-EQVOEEQO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/error-boundary.tsx"],"names":[],"mappings":";;;;AAgEO,IAAM,eAAA,GAAN,cAAoC,KAAA,CAAA,SAAA,CAGzC;AAAA,EACA,YAAY,KAAA,EAA6B;AACvC,IAAA,KAAA,CAAM,KAAK,CAAA;AACX,IAAA,IAAA,CAAK,KAAA,GAAQ,EAAE,QAAA,EAAU,KAAA,EAAO,OAAO,IAAA,EAAK;AAAA,EAC9C;AAAA,EAEA,OAAO,yBAAyB,KAAA,EAAoC;AAClE,IAAA,OAAO,EAAE,QAAA,EAAU,IAAA,EAAM,KAAA,EAAM;AAAA,EACjC;AAAA,EAEA,iBAAA,CAAkB,OAAc,SAAA,EAAkC;AAEhE,IAAA,OAAA,CAAQ,KAAA,CAAM,+BAAA,EAAiC,KAAA,EAAO,SAAS,CAAA;AAG/D,IAAA,IAAI,IAAA,CAAK,MAAM,OAAA,EAAS;AACtB,MAAA,IAAA,CAAK,KAAA,CAAM,OAAA,CAAQ,KAAA,EAAO,SAAS,CAAA;AAAA,IACrC;AAAA,EACF;AAAA,EAEA,mBAAmB,SAAA,EAAuC;AAExD,IAAA,IACE,KAAK,KAAA,CAAM,QAAA,IACX,UAAU,QAAA,KAAa,IAAA,CAAK,MAAM,QAAA,EAClC;AACA,MAAA,IAAA,CAAK,KAAA,EAAM;AAAA,IACb;AAAA,EACF;AAAA,EAEA,QAAQ,MAAY;AAClB,IAAA,IAAA,CAAK,SAAS,EAAE,QAAA,EAAU,KAAA,EAAO,KAAA,EAAO,MAAM,CAAA;AAAA,EAChD,CAAA;AAAA,EAEA,MAAA,GAA0B;AACxB,IAAA,IAAI,IAAA,CAAK,MAAM,QAAA,EAAU;AACvB,MAAA,MAAM,EAAE,QAAA,EAAU,SAAA,EAAU,GAAI,IAAA,CAAK,KAAA;AACrC,MAAA,MAAM,QAAQ,IAAA,CAAK,KAAA,CAAM,KAAA,IAAS,IAAI,MAAM,eAAe,CAAA;AAG3D,MAAA,IAAI,OAAO,aAAa,UAAA,EAAY;AAClC,QAAA,OAAO,QAAA,CAAS,KAAA,EAAO,IAAA,CAAK,KAAK,CAAA;AAAA,MACnC;AAGA,MAAA,IAAI,QAAA,EAAU;AACZ,QAAA,OAAO,QAAA;AAAA,MACT;AAGA,MAAA,uBACE,GAAA;AAAA,QAAC,KAAA;AAAA,QAAA;AAAA,UACC,SAAA,EAAW,EAAA;AAAA,YACT,+DAAA;AAAA,YACA;AAAA,WACF;AAAA,UACA,IAAA,EAAK,OAAA;AAAA,UAEL,QAAA,kBAAA,IAAA,CAAC,KAAA,EAAA,EAAI,SAAA,EAAU,wBAAA,EACb,QAAA,EAAA;AAAA,4BAAA,GAAA,CAAC,KAAA,EAAA,EAAI,WAAU,sBAAA,EACb,QAAA,kBAAA,GAAA;AAAA,cAAC,KAAA;AAAA,cAAA;AAAA,gBACC,SAAA,EAAU,0BAAA;AAAA,gBACV,OAAA,EAAQ,WAAA;AAAA,gBACR,IAAA,EAAK,cAAA;AAAA,gBACL,aAAA,EAAY,MAAA;AAAA,gBAEZ,QAAA,kBAAA,GAAA;AAAA,kBAAC,MAAA;AAAA,kBAAA;AAAA,oBACC,QAAA,EAAS,SAAA;AAAA,oBACT,CAAA,EAAE,+MAAA;AAAA,oBACF,QAAA,EAAS;AAAA;AAAA;AACX;AAAA,aACF,EACF,CAAA;AAAA,4BACA,IAAA,CAAC,KAAA,EAAA,EAAI,SAAA,EAAU,QAAA,EACb,QAAA,EAAA;AAAA,8BAAA,GAAA,CAAC,IAAA,EAAA,EAAG,SAAA,EAAU,wCAAA,EAAyC,QAAA,EAAA,sBAAA,EAEvD,CAAA;AAAA,cACC,MAAM,OAAA,oBACL,GAAA,CAAC,OAAE,SAAA,EAAU,oCAAA,EACV,gBAAM,OAAA,EACT,CAAA;AAAA,8BAEF,GAAA;AAAA,gBAAC,QAAA;AAAA,gBAAA;AAAA,kBACC,IAAA,EAAK,QAAA;AAAA,kBACL,SAAS,IAAA,CAAK,KAAA;AAAA,kBACd,SAAA,EAAU,sQAAA;AAAA,kBACX,QAAA,EAAA;AAAA;AAAA;AAED,aAAA,EACF;AAAA,WAAA,EACF;AAAA;AAAA,OACF;AAAA,IAEJ;AAEA,IAAA,OAAO,KAAK,KAAA,CAAM,QAAA;AAAA,EACpB;AACF;AAMO,SAAS,gBAAA,GAAmB;AACjC,EAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,CAAA,GAAU,eAAuB,IAAI,CAAA;AAE3D,EAAA,IAAI,KAAA,EAAO;AACT,IAAA,MAAM,KAAA;AAAA,EACR;AAEA,EAAA,OAAO;AAAA,IACL,YAAA,EAAc;AAAA,GAChB;AACF","file":"chunk-EQVOEEQO.js","sourcesContent":["'use client'\n\n/**\n * Error Boundary Component for @mdxui/do\n *\n * Catches JavaScript errors anywhere in the child component tree,\n * logs errors, and displays a fallback UI.\n *\n * @example\n * ```tsx\n * <DOErrorBoundary>\n *   <ThingsList />\n * </DOErrorBoundary>\n *\n * // With custom fallback\n * <DOErrorBoundary fallback={<CustomErrorUI />}>\n *   <Dashboard />\n * </DOErrorBoundary>\n *\n * // With fallback function\n * <DOErrorBoundary\n *   fallback={(error, reset) => (\n *     <div>\n *       <p>Error: {error.message}</p>\n *       <button onClick={reset}>Retry</button>\n *     </div>\n *   )}\n * >\n *   <DataView />\n * </DOErrorBoundary>\n * ```\n */\n\nimport * as React from 'react'\nimport { cn } from '../lib/utils'\n\nexport interface DOErrorBoundaryProps {\n  /** Child components to render */\n  children: React.ReactNode\n  /** Custom fallback UI - can be ReactNode or render function */\n  fallback?: React.ReactNode | ((error: Error, reset: () => void) => React.ReactNode)\n  /** Callback when error is caught */\n  onError?: (error: Error, errorInfo: React.ErrorInfo) => void\n  /** Key that triggers reset when changed (useful for route changes) */\n  resetKey?: string | number\n  /** Additional className for the error container */\n  className?: string\n}\n\ninterface DOErrorBoundaryState {\n  hasError: boolean\n  error: Error | null\n}\n\n/**\n * DOErrorBoundary - Catches and handles errors in child components\n *\n * Features:\n * - Catches render errors in child tree\n * - Displays customizable error UI\n * - Provides retry functionality\n * - Supports error callbacks for logging\n * - Resets on resetKey change (e.g., route changes)\n */\nexport class DOErrorBoundary extends React.Component<\n  DOErrorBoundaryProps,\n  DOErrorBoundaryState\n> {\n  constructor(props: DOErrorBoundaryProps) {\n    super(props)\n    this.state = { hasError: false, error: null }\n  }\n\n  static getDerivedStateFromError(error: Error): DOErrorBoundaryState {\n    return { hasError: true, error }\n  }\n\n  componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {\n    // Log error to console\n    console.error('DOErrorBoundary caught error:', error, errorInfo)\n\n    // Call optional error callback\n    if (this.props.onError) {\n      this.props.onError(error, errorInfo)\n    }\n  }\n\n  componentDidUpdate(prevProps: DOErrorBoundaryProps): void {\n    // Reset error state when resetKey changes\n    if (\n      this.state.hasError &&\n      prevProps.resetKey !== this.props.resetKey\n    ) {\n      this.reset()\n    }\n  }\n\n  reset = (): void => {\n    this.setState({ hasError: false, error: null })\n  }\n\n  render(): React.ReactNode {\n    if (this.state.hasError) {\n      const { fallback, className } = this.props\n      const error = this.state.error ?? new Error('Unknown error')\n\n      // Render function fallback\n      if (typeof fallback === 'function') {\n        return fallback(error, this.reset)\n      }\n\n      // ReactNode fallback\n      if (fallback) {\n        return fallback\n      }\n\n      // Default error UI\n      return (\n        <div\n          className={cn(\n            'p-6 rounded-lg bg-destructive/10 border border-destructive/20',\n            className\n          )}\n          role=\"alert\"\n        >\n          <div className=\"flex items-start gap-3\">\n            <div className=\"flex-shrink-0 mt-0.5\">\n              <svg\n                className=\"h-5 w-5 text-destructive\"\n                viewBox=\"0 0 20 20\"\n                fill=\"currentColor\"\n                aria-hidden=\"true\"\n              >\n                <path\n                  fillRule=\"evenodd\"\n                  d=\"M10 18a8 8 0 100-16 8 8 0 000 16zM8.28 7.22a.75.75 0 00-1.06 1.06L8.94 10l-1.72 1.72a.75.75 0 101.06 1.06L10 11.06l1.72 1.72a.75.75 0 101.06-1.06L11.06 10l1.72-1.72a.75.75 0 00-1.06-1.06L10 8.94 8.28 7.22z\"\n                  clipRule=\"evenodd\"\n                />\n              </svg>\n            </div>\n            <div className=\"flex-1\">\n              <h2 className=\"text-sm font-semibold text-destructive\">\n                Something went wrong\n              </h2>\n              {error.message && (\n                <p className=\"mt-1 text-sm text-muted-foreground\">\n                  {error.message}\n                </p>\n              )}\n              <button\n                type=\"button\"\n                onClick={this.reset}\n                className=\"mt-4 inline-flex items-center rounded-md bg-destructive px-3 py-2 text-sm font-semibold text-destructive-foreground shadow-sm hover:bg-destructive/90 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-destructive\"\n              >\n                Try again\n              </button>\n            </div>\n          </div>\n        </div>\n      )\n    }\n\n    return this.props.children\n  }\n}\n\n/**\n * Hook to manually trigger error boundary\n * Useful for catching errors in async operations\n */\nexport function useErrorBoundary() {\n  const [error, setError] = React.useState<Error | null>(null)\n\n  if (error) {\n    throw error\n  }\n\n  return {\n    showBoundary: setError,\n  }\n}\n\nexport default DOErrorBoundary\n"]}

package/dist/chunk-FO3N7SXV.js

@@ -0,0 +1,469 @@
+import { deriveRpcUrl, useHealthCheck } from './chunk-OWEAW4U6.js';
+import * as React from 'react';
+import { QueryClientProvider, QueryClient } from '@tanstack/react-query';
+export { useQueryClient } from '@tanstack/react-query';
+import { newHttpBatchRpcSession } from 'capnweb';
+import { DataProviderContext } from '@mdxui/app';
+import { jsx } from 'react/jsx-runtime';
+
+// src/lib/json-rpc-client.ts
+var endpointCache = /* @__PURE__ */ new Map();
+function createJsonRpcClient(baseUrl) {
+  const rpcUrl = baseUrl.replace(/\/$/, "").replace(/\/rpc$/, "");
+  async function rpcCall(method, args = []) {
+    const response = await fetch(`${rpcUrl}/rpc`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ method, args })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(data.error.message || data.error.code);
+    }
+    return data.result;
+  }
+  async function restCall(path, options) {
+    const response = await fetch(`${rpcUrl}${path}`, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers
+      }
+    });
+    if (!response.ok) {
+      const method = options?.method?.toUpperCase() ?? "GET";
+      if (response.status === 404 && method === "GET") {
+        return { data: [], count: 0 };
+      }
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  return {
+    /**
+     * Namespace operations
+     */
+    Namespace: {
+      async list(_params) {
+        return [{ id: "default", name: "default" }];
+      }
+    },
+    /**
+     * Schema operations
+     */
+    Schema: {
+      async discover(_params) {
+        const schemas = await rpcCall("schemas.list", []);
+        return {
+          namespaces: ["default"],
+          types: schemas,
+          schemas
+        };
+      },
+      async get(params) {
+        const result = await rpcCall("schemas.get", [params.type]);
+        return result;
+      }
+    },
+    /**
+     * Thing operations (maps to REST endpoints)
+     */
+    Thing: {
+      async types(params) {
+        try {
+          const schemas = await rpcCall("schemas.list", []);
+          let validEndpoints = endpointCache.get(rpcUrl);
+          if (!validEndpoints) {
+            validEndpoints = /* @__PURE__ */ new Set();
+            const probeResults = await Promise.all(
+              schemas.map(async (type) => {
+                const endpoint = getEndpointForType(type);
+                try {
+                  const response = await fetch(`${rpcUrl}${endpoint}`, { method: "HEAD" });
+                  return { type, exists: response.ok };
+                } catch {
+                  try {
+                    const response = await fetch(`${rpcUrl}${endpoint}?limit=0`);
+                    return { type, exists: response.ok };
+                  } catch {
+                    return { type, exists: false };
+                  }
+                }
+              })
+            );
+            for (const { type, exists } of probeResults) {
+              if (exists) {
+                validEndpoints.add(type);
+              }
+            }
+            endpointCache.set(rpcUrl, validEndpoints);
+          }
+          return Array.from(validEndpoints).map((name) => ({
+            name,
+            ns: params.ns || "default"
+          }));
+        } catch {
+          return ["Noun", "Verb", "Action", "Function"].map((name) => ({
+            name,
+            ns: params.ns || "default"
+          }));
+        }
+      },
+      async list(params) {
+        const endpoint = getEndpointForType(params.type || "Thing");
+        const response = await restCall(endpoint);
+        const items = response.data || response.items || response.result || [];
+        return {
+          data: items,
+          total: response.count ?? items.length
+        };
+      },
+      async get(params) {
+        const endpoint = getEndpointForType(params.type);
+        const response = await restCall(`${endpoint}/${params.id}`);
+        return response.data;
+      },
+      async create(params) {
+        const endpoint = getEndpointForType(params.type);
+        const response = await restCall(endpoint, {
+          method: "POST",
+          body: JSON.stringify(params.data)
+        });
+        return response.data;
+      },
+      async update(params) {
+        const endpoint = getEndpointForType(params.type);
+        const response = await restCall(`${endpoint}/${params.id}`, {
+          method: "PUT",
+          body: JSON.stringify(params.data)
+        });
+        return response.data;
+      },
+      async delete(params) {
+        const endpoint = getEndpointForType(params.type);
+        await restCall(`${endpoint}/${params.id}`, { method: "DELETE" });
+        return { success: true };
+      },
+      async versions(_params) {
+        return [];
+      },
+      async stats(_params) {
+        let validEndpoints = endpointCache.get(rpcUrl);
+        if (!validEndpoints) {
+          await this.types({ ns: _params.ns });
+          validEndpoints = endpointCache.get(rpcUrl) || /* @__PURE__ */ new Set();
+        }
+        const types = Array.from(validEndpoints);
+        const results = await Promise.all(
+          types.map(async (type) => {
+            const endpoint = getEndpointForType(type);
+            const response = await restCall(endpoint).catch(() => ({ count: 0 }));
+            return { type, count: response.count || 0 };
+          })
+        );
+        const byType = {};
+        let total = 0;
+        for (const { type, count } of results) {
+          byType[type] = count;
+          total += count;
+        }
+        return { total, byType };
+      }
+    },
+    /**
+     * SQL operations
+     */
+    SQL: {
+      async execute(params) {
+        const startTime = Date.now();
+        try {
+          const result = await rpcCall("sql.execute", [params.query, params.params || []]);
+          return {
+            rows: result.rows ?? [],
+            columns: result.columns ?? [],
+            rowsAffected: result.rowsAffected,
+            executionTimeMs: result.executionTimeMs ?? Date.now() - startTime
+          };
+        } catch (rpcError) {
+          const errorMessage = rpcError instanceof Error ? rpcError.message : String(rpcError);
+          const isNotSupported = errorMessage.includes("not found") || errorMessage.includes("not supported") || errorMessage.includes("unknown method");
+          try {
+            const response = await restCall("/sql", {
+              method: "POST",
+              body: JSON.stringify({ query: params.query, params: params.params })
+            });
+            return {
+              rows: response.rows ?? [],
+              columns: response.columns ?? [],
+              rowsAffected: response.rowsAffected,
+              executionTimeMs: Date.now() - startTime
+            };
+          } catch (restError) {
+            if (isNotSupported) {
+              throw new Error(
+                "SQL execution is not supported by this server. The server does not expose sql.execute RPC method or /sql REST endpoint."
+              );
+            }
+            throw restError;
+          }
+        }
+      }
+    },
+    // Required for interface compatibility
+    dup: () => createJsonRpcClient(baseUrl),
+    onRpcBroken: (_callback) => {
+    },
+    [Symbol.dispose]: () => {
+    }
+  };
+}
+function getEndpointForType(type) {
+  const typeMap = {
+    Noun: "/nouns",
+    Verb: "/verbs",
+    Action: "/actions",
+    Function: "/functions",
+    Event: "/events",
+    Relationship: "/relationships",
+    Thing: "/things",
+    Workflow: "/workflows"
+  };
+  return typeMap[type] || `/${type.toLowerCase()}s`;
+}
+function $JsonRpcContext(url) {
+  return createJsonRpcClient(url);
+}
+function createCapnwebClient(baseUrl) {
+  const rpcUrl = `${baseUrl.replace(/\/$/, "").replace(/\/rpc$/, "")}/rpc`;
+  const session = newHttpBatchRpcSession(rpcUrl);
+  const rpc = session;
+  return {
+    /**
+     * Namespace operations
+     */
+    Namespace: {
+      async list(_params) {
+        return [{ id: "default", name: "default" }];
+      }
+    },
+    /**
+     * Schema operations
+     */
+    Schema: {
+      async discover(_params) {
+        try {
+          const schemas = await rpc.getSchemas();
+          return {
+            namespaces: ["default"],
+            types: schemas ?? [],
+            schemas: schemas ?? []
+          };
+        } catch (error) {
+          console.error("[@mdxui/do] Failed to get schemas:", error);
+          return { namespaces: ["default"], types: [], schemas: [] };
+        }
+      },
+      async get(params) {
+        try {
+          const result = await rpc.getSchema(params.type);
+          return result;
+        } catch {
+          return null;
+        }
+      }
+    },
+    /**
+     * Thing operations
+     */
+    Thing: {
+      async types(params) {
+        try {
+          const schemas = await rpc.getSchemas();
+          return (schemas ?? []).map((name) => ({
+            name,
+            ns: params.ns || "default"
+          }));
+        } catch (error) {
+          console.error("[@mdxui/do] Failed to get types:", error);
+          return [];
+        }
+      },
+      async list(params) {
+        try {
+          const options = {};
+          if (params.type) options.type = params.type;
+          if (params.limit !== void 0) options.limit = params.limit;
+          if (params.offset !== void 0) options.offset = params.offset;
+          const result = await rpc.list(options);
+          if (Array.isArray(result)) {
+            return { data: result, total: result.length };
+          }
+          if (result) {
+            const items = result.data || result.items || result.result || [];
+            return { data: items, total: result.count ?? items.length };
+          }
+          return { data: [], total: 0 };
+        } catch (error) {
+          console.error("[@mdxui/do] Failed to list things:", error);
+          return { data: [], total: 0 };
+        }
+      },
+      async get(params) {
+        try {
+          const result = await rpc.get({ type: params.type, id: params.id });
+          return result;
+        } catch {
+          return null;
+        }
+      },
+      async create(params) {
+        const result = await rpc.create({ type: params.type, data: params.data });
+        return result;
+      },
+      async update(params) {
+        const result = await rpc.update({ type: params.type, id: params.id, data: params.data });
+        return result;
+      },
+      async delete(params) {
+        await rpc.delete({ type: params.type, id: params.id });
+        return { success: true };
+      },
+      async versions(_params) {
+        return [];
+      },
+      async stats(_params) {
+        try {
+          const options = {};
+          if (_params.type) options.type = _params.type;
+          const result = await rpc.getStats(options);
+          return {
+            total: result?.total ?? 0,
+            byType: result?.byType ?? {}
+          };
+        } catch (error) {
+          console.error("[@mdxui/do] Failed to get stats:", error);
+          return { total: 0, byType: {} };
+        }
+      }
+    },
+    /**
+     * SQL operations (not supported by capnweb servers)
+     */
+    SQL: {
+      async execute(_params) {
+        throw new Error("SQL execution is not supported by this server");
+      }
+    },
+    // Required for interface compatibility
+    dup: () => createCapnwebClient(baseUrl),
+    onRpcBroken: (callback) => {
+      if ("onRpcBroken" in session && typeof session.onRpcBroken === "function") {
+        session.onRpcBroken(callback);
+      }
+    },
+    [Symbol.dispose]: () => {
+      if (Symbol.dispose in session) {
+        session[Symbol.dispose]();
+      }
+    }
+  };
+}
+function $CapnwebContext(url) {
+  return createCapnwebClient(url);
+}
+function createQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        // Stale time: 30 seconds (data considered fresh)
+        staleTime: 30 * 1e3,
+        // Cache time: 5 minutes (keep in cache after unmount)
+        gcTime: 5 * 60 * 1e3,
+        // Retry failed requests 1 time
+        retry: 1,
+        // Refetch on window focus for fresh data
+        refetchOnWindowFocus: true
+      },
+      mutations: {
+        // Retry mutations once on failure
+        retry: 1
+      }
+    }
+  });
+}
+var DOContext = React.createContext(null);
+function useDO() {
+  const context = React.useContext(DOContext);
+  if (!context) {
+    throw new Error("useDO must be used within a DOProvider");
+  }
+  return context;
+}
+function useDOClient() {
+  const { client } = useDO();
+  return client;
+}
+function useDOUrls() {
+  const { rpcUrl, config } = useDO();
+  return {
+    rpcUrl,
+    apiEndpoint: config.apiEndpoint
+  };
+}
+function useSyncStatus() {
+  return "disconnected";
+}
+function DOProvider({
+  config,
+  initialNamespace = "default",
+  userId,
+  children,
+  queryClient: providedQueryClient
+}) {
+  const [namespace, setNamespace] = React.useState(initialNamespace);
+  const rpcUrl = config.rpcUrl ?? deriveRpcUrl(config.apiEndpoint);
+  const client = React.useMemo(() => {
+    const clientType = config.clientType ?? "capnweb";
+    if (process.env.NODE_ENV === "development") {
+      const url = clientType === "json-rpc" ? config.apiEndpoint : rpcUrl;
+      console.log(`[@mdxui/do] Initializing ${clientType} client with URL: ${url}`);
+    }
+    if (clientType === "json-rpc") {
+      return $JsonRpcContext(config.apiEndpoint);
+    }
+    return $CapnwebContext(rpcUrl);
+  }, [rpcUrl, config.apiEndpoint, config.clientType]);
+  const healthCheckResult = useHealthCheck({
+    apiEndpoint: config.apiEndpoint,
+    authToken: config.authToken,
+    requestTimeout: config.requestTimeout,
+    healthCheckRetries: config.healthCheckRetries
+  });
+  const isConnected = config.skipHealthCheck ? true : healthCheckResult.isConnected;
+  const connectionError = config.skipHealthCheck ? void 0 : healthCheckResult.connectionError;
+  const [queryClient] = React.useState(() => providedQueryClient ?? createQueryClient());
+  const value = React.useMemo(
+    () => ({
+      config,
+      namespace,
+      setNamespace,
+      userId,
+      isConnected,
+      connectionError,
+      rpcUrl,
+      client
+    }),
+    [config, namespace, userId, isConnected, connectionError, rpcUrl, client]
+  );
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(DOContext.Provider, { value, children }) });
+}
+function useDataProviderSafe() {
+  return React.useContext(DataProviderContext);
+}
+
+export { DOProvider, useDO, useDOClient, useDOUrls, useDataProviderSafe, useSyncStatus };
+//# sourceMappingURL=chunk-FO3N7SXV.js.map
+//# sourceMappingURL=chunk-FO3N7SXV.js.map