@alfadocs/ui-kit 1.22.0 → 1.23.0

package/dist/_chunks/error-boundary-ayXFCcq4.js

@@ -0,0 +1,90 @@
+var h = Object.defineProperty;
+var u = (n, e, r) => e in n ? h(n, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : n[e] = r;
+var i = (n, e, r) => u(n, typeof e != "symbol" ? e + "" : e, r);
+import { jsx as a, Fragment as y } from "react/jsx-runtime";
+import { Component as f } from "react";
+import { useTranslation as v } from "react-i18next";
+import { E } from "./empty-state-X0sVPfVo.js";
+function p({
+  size: n,
+  title: e,
+  description: r,
+  onRetry: o
+}) {
+  const { t } = v();
+  return /* @__PURE__ */ a(
+    E,
+    {
+      variant: "error",
+      size: n,
+      ...e === void 0 ? {} : { title: e },
+      ...r === void 0 ? {} : { description: r },
+      ...o === void 0 ? {} : {
+        primaryAction: {
+          label: t("emptyState.error.cta"),
+          onClick: o
+        }
+      }
+    }
+  );
+}
+p.displayName = "ErrorBoundaryFallback";
+class b extends f {
+  constructor() {
+    super(...arguments);
+    i(this, "state", { error: null });
+    i(this, "reset", () => {
+      this.setState({ error: null });
+    });
+    i(this, "handleRetry", () => {
+      var r, o;
+      (o = (r = this.props).onRetry) == null || o.call(r), this.reset();
+    });
+  }
+  static getDerivedStateFromError(r) {
+    return { error: r };
+  }
+  componentDidCatch(r, o) {
+    var t, s;
+    (s = (t = this.props).onError) == null || s.call(t, r, o);
+  }
+  /**
+   * A changed key clears the error. Compared by identity and in order, so a
+   * host passing a fresh array of the same values does not re-render into the
+   * same failure forever.
+   *
+   * `previousState` is load-bearing. React commits the caught error as an
+   * ordinary update, so the first `componentDidUpdate` after a catch still sees
+   * the props from the last HEALTHY commit. When the prop change is itself what
+   * crashed the child — `resetKeys={[patientId]}` around something that throws
+   * on the new patient, which is the documented use — the keys have moved, and
+   * without this guard the boundary would clear on the very commit that caught
+   * and render straight back into the failure. It settles on the second catch,
+   * but the subtree renders twice and `onError` fires twice for one crash.
+   */
+  componentDidUpdate(r, o) {
+    if (this.state.error === null || o.error === null) return;
+    const t = r.resetKeys, s = this.props.resetKeys;
+    if (t === void 0 || s === void 0) return;
+    (t.length !== s.length || s.some((l, d) => !Object.is(l, t[d]))) && this.reset();
+  }
+  render() {
+    const { error: r } = this.state, { children: o, fallback: t, title: s, description: c, onRetry: l, size: d } = this.props;
+    if (r === null) return /* @__PURE__ */ a(y, { children: o });
+    const m = typeof t == "function" ? t({ error: r, reset: this.handleRetry }) : t !== void 0 ? t : /* @__PURE__ */ a(
+      p,
+      {
+        size: d,
+        title: s,
+        description: c,
+        ...l === void 0 ? {} : { onRetry: this.handleRetry }
+      }
+    );
+    return /* @__PURE__ */ a("div", { "data-component": "error-boundary", children: m });
+  }
+}
+i(b, "displayName", "ErrorBoundary");
+export {
+  b as E
+};
+//# sourceMappingURL=error-boundary-ayXFCcq4.js.map

package/dist/agent-catalog.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "packageVersion": "1.22.0",
+  "packageVersion": "1.23.0",
   "components": [
     {
       "kind": "component",
@@ -4612,6 +4612,20 @@
         }
       }
     },
+    {
+      "kind": "component",
+      "id": "error-boundary",
+      "capabilities": [],
+      "state": [],
+      "actions": [],
+      "domHooks": {
+        "root": {
+          "attr": "data-component",
+          "value": "error-boundary",
+          "description": "Wraps whatever the boundary shows once it has caught — the default face or a host fallback alike. Present only after a catch, so its absence means the tree below is healthy."
+        }
+      }
+    },
     {
       "kind": "component",
       "id": "face-scheme",

package/dist/components/error-boundary/error-boundary.d.ts

@@ -0,0 +1,88 @@
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+/** What the boundary caught, handed to a render-prop fallback. */
+export interface ErrorBoundaryState {
+    error: Error;
+    /**
+     * Runs `onRetry` if the host gave one, then clears the error and re-renders
+     * the children — the same call the default face's action makes, so a host
+     * that replaces the face does not silently lose its own recovery.
+     */
+    reset: () => void;
+}
+export interface ErrorBoundaryProps {
+    children?: ReactNode;
+    /**
+     * Replaces the default face. A function receives the error and a `reset`,
+     * so a host can offer its own recovery instead of a reload.
+     */
+    fallback?: ReactNode | ((state: ErrorBoundaryState) => ReactNode);
+    /** Report the crash — logging, telemetry, a support channel. */
+    onError?: (error: Error, info: ErrorInfo) => void;
+    /**
+     * Clear the error when any of these change, so a route change or a new
+     * record recovers without the user pressing anything.
+     */
+    resetKeys?: readonly unknown[];
+    /** Overrides for the default face; each falls back to the kit's own copy. */
+    title?: string;
+    description?: string;
+    /**
+     * Shown as the face's action, and run by a render-prop's `reset` too.
+     *
+     * Called BEFORE the boundary clears. That is enough for a synchronous
+     * recovery — a state flip, a cache clear. It is NOT enough on its own for an
+     * async one: the boundary clears on the next line, so a refetch that has not
+     * resolved re-renders into the same failure. Pair an async recovery with
+     * `resetKeys`, so the settled data is what clears the error.
+     */
+    onRetry?: () => void;
+    size?: 'sm' | 'md' | 'lg';
+}
+/**
+ * Catches a render error below it and shows the kit's error face instead of
+ * unmounting the tree to a blank page.
+ *
+ * A CLASS COMPONENT, by sanctioned exception — see
+ * `src/docs/23-constraints.mdx` §9. React 18 exposes `getDerivedStateFromError`
+ * and `componentDidCatch` on classes only; there is no hook form, and no
+ * function component can catch a descendant's render error. The exception is
+ * this file, and it is the reason the kit had no boundary at all.
+ *
+ * It catches RENDER errors. An event handler, a timeout or a rejected promise
+ * never reaches it — React does not route those through a boundary — so a host
+ * still handles its own async failures.
+ */
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, {
+    error: Error | null;
+}> {
+    static displayName: string;
+    state: {
+        error: Error | null;
+    };
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    /**
+     * A changed key clears the error. Compared by identity and in order, so a
+     * host passing a fresh array of the same values does not re-render into the
+     * same failure forever.
+     *
+     * `previousState` is load-bearing. React commits the caught error as an
+     * ordinary update, so the first `componentDidUpdate` after a catch still sees
+     * the props from the last HEALTHY commit. When the prop change is itself what
+     * crashed the child — `resetKeys={[patientId]}` around something that throws
+     * on the new patient, which is the documented use — the keys have moved, and
+     * without this guard the boundary would clear on the very commit that caught
+     * and render straight back into the failure. It settles on the second catch,
+     * but the subtree renders twice and `onError` fires twice for one crash.
+     */
+    componentDidUpdate(previous: ErrorBoundaryProps, previousState: {
+        error: Error | null;
+    }): void;
+    reset: () => void;
+    handleRetry: () => void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export { ErrorBoundary };
+//# sourceMappingURL=error-boundary.d.ts.map

package/dist/components/error-boundary/index.d.ts

@@ -0,0 +1,3 @@
+export { ErrorBoundary } from './error-boundary';
+export type { ErrorBoundaryProps, ErrorBoundaryState } from './error-boundary';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/error-boundary/index.js

@@ -0,0 +1,5 @@
+import { E as a } from "../../_chunks/error-boundary-ayXFCcq4.js";
+export {
+  a as ErrorBoundary
+};
+//# sourceMappingURL=index.js.map

package/dist/components/index.d.ts

@@ -116,6 +116,7 @@ export * from './appointment-card';
 export * from './appointment-timeline';
 export * from './dialog';
 export * from './dropdown-menu';
+export * from './error-boundary';
 export * from './finished-terminal';
 export * from './info-tip';
 export * from './live-region';