@ariestools/sdk-react 10.0.2

package/dist/_pkg/error/browser/index.mjs

@@ -0,0 +1,442 @@
+// src/components/ErrorBoundary.tsx
+import { FlexCol } from "../../flexbox/browser/index.mjs";
+import { Typography } from "@mui/material";
+import { Component } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { error: void 0 };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error(error, errorInfo);
+  }
+  render() {
+    if (this.state.error) {
+      if (this.props.fallbackWithError) {
+        return this.props.fallbackWithError(this.state.error);
+      }
+      return this.props.fallback ?? /* @__PURE__ */ jsxs(FlexCol, { children: [
+        /* @__PURE__ */ jsx(Typography, { variant: "h1", children: "Something went wrong." }),
+        this.props.scope !== void 0 && this.props.scope !== "" && /* @__PURE__ */ jsxs(Typography, { variant: "h2", children: [
+          "[",
+          this.props.scope,
+          "]"
+        ] }),
+        /* @__PURE__ */ jsxs(Typography, { variant: "body1", children: [
+          "[",
+          this.state.error?.message,
+          "]"
+        ] })
+      ] });
+    }
+    return this.props.children;
+  }
+};
+
+// src/components/ErrorBoundary/ThrownErrorBoundary.tsx
+import { Component as Component2 } from "react";
+
+// src/contexts/ErrorReporter/Provider.tsx
+import { useMemo } from "react";
+
+// src/contexts/ErrorReporter/Context.ts
+import { createContext } from "react";
+var ErrorReporterContext = createContext({});
+
+// src/contexts/ErrorReporter/Provider.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ErrorReporterProvider = ({ children, rollbar: rollbarProp }) => {
+  if (rollbarProp === void 0 && globalThis.rollbar === void 0) {
+    throw new Error("ErrorReporterProvider unable to find a Rollbar instance either passed as prop or from Provider");
+  }
+  const rollbar = rollbarProp ?? globalThis.rollbar;
+  const value = useMemo(() => ({ rollbar }), [rollbar]);
+  return /* @__PURE__ */ jsx2(ErrorReporterContext, { value, children });
+};
+
+// src/contexts/ErrorReporter/useErrorReporter.tsx
+import { use } from "react";
+var useErrorReporter = () => {
+  const context = use(ErrorReporterContext);
+  if (context === void 0) {
+    console.warn("useErrorReporter must be used within a ErrorReporterContext");
+  }
+  return context ?? {};
+};
+
+// src/components/ErrorRender/ErrorAlert.tsx
+import { ButtonEx } from "../../button/browser/index.mjs";
+import { FlexCol as FlexCol2, FlexRow } from "../../flexbox/browser/index.mjs";
+import { ChevronRight, ExitToApp as ExitIcon } from "@mui/icons-material";
+import {
+  Alert,
+  AlertTitle,
+  Grow,
+  Stack,
+  Typography as Typography2,
+  useTheme
+} from "@mui/material";
+import { useState } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function ErrorAlert({
+  action,
+  additionalMessaging,
+  title = "Whoops! Something went wrong",
+  onCancel,
+  error = "An unknown error occurred",
+  scope,
+  sx,
+  ...props
+}) {
+  const theme = useTheme();
+  const [openDetails, setOpenDetails] = useState(false);
+  return /* @__PURE__ */ jsxs2(
+    Alert,
+    {
+      action: /* @__PURE__ */ jsxs2(FlexRow, { sx: { gap: 0.5 }, children: [
+        action,
+        onCancel ? /* @__PURE__ */ jsx3(
+          ButtonEx,
+          {
+            color: "error",
+            variant: "outlined",
+            size: "small",
+            onClick: onCancel,
+            children: /* @__PURE__ */ jsx3(ExitIcon, { fontSize: "small" })
+          }
+        ) : null
+      ] }),
+      severity: "error",
+      sx: { maxWidth: theme.breakpoints.values.sm, ...sx },
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx3(AlertTitle, { children: title }),
+        /* @__PURE__ */ jsxs2(
+          FlexCol2,
+          {
+            sx: {
+              width: "100%",
+              alignItems: "start",
+              justifyContent: "center",
+              gap: 1
+            },
+            children: [
+              additionalMessaging,
+              /* @__PURE__ */ jsxs2(
+                FlexRow,
+                {
+                  sx: {
+                    gap: 0.5,
+                    cursor: "pointer"
+                  },
+                  onClick: () => setOpenDetails(!openDetails),
+                  children: [
+                    /* @__PURE__ */ jsx3(Typography2, { variant: "caption", sx: { fontWeight: "bold" }, children: "Details:" }),
+                    openDetails ? /* @__PURE__ */ jsx3(ChevronRight, { sx: { fontSize: "1.1rem", transform: "rotate(90deg)" } }) : /* @__PURE__ */ jsx3(ChevronRight, { sx: { fontSize: "1.1rem" } })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx3(Grow, { in: openDetails, unmountOnExit: true, children: /* @__PURE__ */ jsxs2(Stack, { sx: { hyphens: "auto", maxWidth: "100%" }, children: [
+                scope !== void 0 && scope !== "" ? /* @__PURE__ */ jsxs2(
+                  Stack,
+                  {
+                    direction: "row",
+                    sx: {
+                      gap: 0.25,
+                      maxWidth: "100%"
+                    },
+                    children: [
+                      /* @__PURE__ */ jsx3(Typography2, { variant: "caption", sx: { mr: 0.5, fontWeight: "bold" }, children: "Scope:" }),
+                      /* @__PURE__ */ jsx3(Typography2, { variant: "caption", children: scope })
+                    ]
+                  }
+                ) : null,
+                /* @__PURE__ */ jsxs2("div", { children: [
+                  /* @__PURE__ */ jsx3(Typography2, { variant: "caption", sx: { mr: 0.5, fontWeight: "bold" }, children: "Error:" }),
+                  /* @__PURE__ */ jsx3(Typography2, { variant: "caption", children: typeof error === "string" ? error : error?.message })
+                ] })
+              ] }) })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/ErrorRender/ErrorRenderWithSupport.tsx
+import { BugReport } from "@mui/icons-material";
+import {
+  IconButton,
+  Link,
+  Tooltip
+} from "@mui/material";
+import { useMemo as useMemo2 } from "react";
+
+// src/components/ErrorRender/Render.tsx
+import { FlexCol as FlexCol3 } from "../../flexbox/browser/index.mjs";
+import { useEffect } from "react";
+import { Fragment, jsx as jsx4 } from "react/jsx-runtime";
+function ErrorRender({
+  onCancel,
+  error,
+  noErrorDisplay = false,
+  customError = null,
+  children,
+  scope,
+  useLocation,
+  slotProps,
+  sx,
+  ...props
+}) {
+  const location = useLocation?.();
+  useEffect(() => {
+    if (location) {
+      Object.assign(location, { state: { from: { pathname: globalThis.location.pathname } } });
+    }
+  }, [location]);
+  useEffect(() => {
+    if (error) {
+      globalThis.rollbar?.error(error);
+    }
+  }, [error]);
+  return error ? /* @__PURE__ */ jsx4(
+    FlexCol3,
+    {
+      ...props,
+      sx: { alignItems: "stretch" },
+      children: noErrorDisplay ? customError : /* @__PURE__ */ jsx4(
+        FlexCol3,
+        {
+          ...props,
+          sx: { alignItems: "center" },
+          children: /* @__PURE__ */ jsx4(ErrorAlert, { error, onCancel, scope, sx: { position: "relative", ...sx }, ...slotProps?.alert })
+        }
+      )
+    }
+  ) : /* @__PURE__ */ jsx4(Fragment, { children });
+}
+
+// src/components/ErrorRender/ErrorRenderWithSupport.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var ErrorRenderWithSupport = ({
+  supportHref,
+  supportIcon,
+  supportLinkTitle = "Support",
+  slotProps,
+  ...props
+}) => {
+  const combinedSlotProps = useMemo2(() => ({
+    ...slotProps,
+    alert: {
+      ...slotProps?.alert,
+      action: supportHref !== void 0 && supportHref !== "" && /* @__PURE__ */ jsx5(Link, { href: supportHref, target: "_blank", children: /* @__PURE__ */ jsx5(Tooltip, { title: supportLinkTitle, children: /* @__PURE__ */ jsx5(IconButton, { color: "error", size: "small", children: supportIcon ?? /* @__PURE__ */ jsx5(BugReport, {}) }) }) })
+    }
+  }), [slotProps, supportHref, supportIcon, supportLinkTitle]);
+  return /* @__PURE__ */ jsx5(
+    ErrorRender,
+    {
+      slotProps: combinedSlotProps,
+      ...props
+    }
+  );
+};
+
+// src/components/ErrorRender/Popover.tsx
+import { InfoOutlined } from "@mui/icons-material";
+import { Icon, Popover } from "@mui/material";
+import { useState as useState2 } from "react";
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+var PopoverErrorRender = ({
+  error,
+  scope,
+  ...props
+}) => {
+  const [open, setOpen] = useState2(false);
+  const [anchor, setAnchor] = useState2(null);
+  return error && /* @__PURE__ */ jsxs3(
+    Icon,
+    {
+      onMouseEnter: () => setOpen(true),
+      onMouseLeave: () => setOpen(false),
+      ref: setAnchor,
+      sx: {
+        alignItems: "center",
+        cursor: "pointer",
+        display: "inline-flex"
+      },
+      children: [
+        /* @__PURE__ */ jsx6(InfoOutlined, { color: "error", fontSize: "small" }),
+        /* @__PURE__ */ jsx6(
+          Popover,
+          {
+            anchorOrigin: { vertical: "top", horizontal: "right" },
+            anchorEl: anchor,
+            onClose: () => setOpen(false),
+            open,
+            ...props,
+            children: /* @__PURE__ */ jsx6(ErrorRender, { error, scope })
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/components/ErrorBoundary/ThrownErrorBoundary.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var ThrownErrorBoundaryInner = class extends Component2 {
+  state = { errorEx: void 0 };
+  static getDerivedStateFromError(error) {
+    const thrownErrorBoundaryState = {
+      hasError: true,
+      errorEx: error,
+      xyoError: this.normalizeError(error)
+    };
+    return thrownErrorBoundaryState;
+  }
+  static normalizeError(error) {
+    return error;
+  }
+  componentDidCatch(error, errorInfo) {
+    const { rethrow, rollbar } = this.props;
+    const { errorEx } = this.state;
+    rollbar?.error(error);
+    console.error("Error:", errorEx, errorInfo);
+    if (rethrow === true) {
+      throw error;
+    }
+  }
+  render() {
+    const { errorEx } = this.state;
+    const {
+      children,
+      boundaryName,
+      errorComponent,
+      scope,
+      title
+    } = this.props;
+    if (errorEx) {
+      if (errorComponent) {
+        return errorComponent(errorEx, boundaryName);
+      }
+      return /* @__PURE__ */ jsx7(ErrorRender, { error: errorEx, errorContext: `${boundaryName} Boundary`, scope, title });
+    }
+    return children;
+  }
+};
+function ThrownErrorBoundary({ rollbar, ...props }) {
+  const { rollbar: rollbarErrorReporter } = useErrorReporter();
+  return /* @__PURE__ */ jsx7(ThrownErrorBoundaryInner, { rollbar: rollbar ?? rollbarErrorReporter ?? globalThis.rollbar, ...props });
+}
+
+// src/components/ErrorQuickTipButton.tsx
+import { isDefined } from "@ariestools/sdk";
+import { FlexCol as FlexCol4 } from "../../flexbox/browser/index.mjs";
+import { QuickTipButton } from "../../quick-tip-button/browser/index.mjs";
+import { CancelRounded as CancelRoundedIcon, CheckCircleOutlineRounded as CheckCircleOutlineRoundedIcon } from "@mui/icons-material";
+import { Typography as Typography3 } from "@mui/material";
+import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+var InvalidIcon = ({ ref, ...props }) => /* @__PURE__ */ jsx8(CancelRoundedIcon, { color: "error", ref, ...props });
+InvalidIcon.displayName = "InvalidIcon";
+var ErrorQuickTipButton = ({
+  boundWitnessType = "Bound Witness",
+  errors,
+  iconColors,
+  validateError,
+  ...props
+}) => {
+  const hasErrors = isDefined(errors) && errors.length > 0;
+  return /* @__PURE__ */ jsx8(
+    QuickTipButton,
+    {
+      Icon: hasErrors ? ({ ref, ...props2 }) => {
+        return /* @__PURE__ */ jsx8(InvalidIcon, { color: iconColors === true ? "error" : void 0, ref, ...props2 });
+      } : ({ ref, ...props2 }) => {
+        return /* @__PURE__ */ jsx8(CheckCircleOutlineRoundedIcon, { color: iconColors === true ? "success" : void 0, ref, ...props2 });
+      },
+      hoverText: hasErrors ? `Invalid ${boundWitnessType}` : "Valid",
+      ...props,
+      children: hasErrors ? /* @__PURE__ */ jsxs4(
+        FlexCol4,
+        {
+          sx: {
+            flexWrap: "wrap",
+            alignItems: "start"
+          },
+          children: [
+            /* @__PURE__ */ jsx8(ErrorRender, { error: validateError, scope: "VerificationError" }),
+            errors.map((error) => {
+              return /* @__PURE__ */ jsx8(Typography3, { children: error.toString() }, error.name);
+            })
+          ]
+        }
+      ) : /* @__PURE__ */ jsx8(Typography3, { children: "No Errors" })
+    }
+  );
+};
+
+// src/components/Errors/ErrorsViewer.tsx
+import { FlexGrowCol } from "../../flexbox/browser/index.mjs";
+import { Replay as ReplayIcon } from "@mui/icons-material";
+import { IconButton as IconButton2 } from "@mui/material";
+
+// src/components/Errors/ErrorViewer.tsx
+import { FlexCol as FlexCol5 } from "../../flexbox/browser/index.mjs";
+import { Typography as Typography4, useTheme as useTheme2 } from "@mui/material";
+import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+var ErrorViewer = (props) => {
+  const { error, ...boxProps } = props;
+  const theme = useTheme2();
+  return /* @__PURE__ */ jsxs5(
+    FlexCol5,
+    {
+      ...boxProps,
+      sx: { color: theme.vars.palette.error.main },
+      children: [
+        /* @__PURE__ */ jsx9(Typography4, { align: "center", variant: "subtitle1", children: error?.name }),
+        /* @__PURE__ */ jsx9(Typography4, { align: "center", variant: "body2", children: error?.message })
+      ]
+    }
+  );
+};
+
+// src/components/Errors/ErrorsViewer.tsx
+import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var ErrorsViewer = (props) => {
+  const {
+    onRetry,
+    errors,
+    ...boxProps
+  } = props;
+  return /* @__PURE__ */ jsxs6(
+    FlexGrowCol,
+    {
+      ...boxProps,
+      sx: { padding: 1 },
+      children: [
+        errors?.map((error) => {
+          return /* @__PURE__ */ jsx10(ErrorViewer, { error }, error.message);
+        }),
+        onRetry ? /* @__PURE__ */ jsx10(IconButton2, { onClick: onRetry, children: /* @__PURE__ */ jsx10(ReplayIcon, {}) }) : null
+      ]
+    }
+  );
+};
+export {
+  ErrorAlert,
+  ErrorBoundary,
+  ErrorQuickTipButton,
+  ErrorRender,
+  ErrorRenderWithSupport,
+  ErrorReporterProvider,
+  ErrorViewer,
+  ErrorsViewer,
+  PopoverErrorRender,
+  ThrownErrorBoundary,
+  useErrorReporter
+};

package/dist/_pkg/experiments/browser/components/Experiment.d.ts

@@ -0,0 +1,7 @@
+import type { PropsWithChildren } from 'react';
+import React from 'react';
+export interface ExperimentProps {
+    key: string;
+    weight: number;
+}
+export declare const Experiment: React.FC<PropsWithChildren<ExperimentProps>>;

package/dist/_pkg/experiments/browser/components/Experiments.d.ts

@@ -0,0 +1,4 @@
+import type React from 'react';
+import type { ExperimentsProps } from './ExperimentsProps.ts';
+declare const Experiments: React.FC<ExperimentsProps>;
+export { Experiments };

package/dist/_pkg/experiments/browser/components/ExperimentsDebugger.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const ExperimentsDebugger: React.FC;
+export { ExperimentsDebugger };

package/dist/_pkg/experiments/browser/components/ExperimentsProps.d.ts

@@ -0,0 +1,7 @@
+import type { ReactElement } from 'react';
+import type { ExperimentProps } from './Experiment.tsx';
+export interface ExperimentsProps {
+    children: ReactElement<ExperimentProps>[] | ReactElement<ExperimentProps>;
+    localStorageProp?: string | boolean;
+    name: string;
+}

package/dist/_pkg/experiments/browser/components/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Experiment.tsx';
+export * from './Experiments.tsx';
+export * from './ExperimentsDebugger.tsx';
+export * from './ExperimentsProps.ts';
+export * from './models/index.ts';

package/dist/_pkg/experiments/browser/components/models/index.d.ts

@@ -0,0 +1,12 @@
+export declare const OutcomesLocalStorageKey = "outcomes";
+export declare const ExperimentsLocalStorageKey = "experiments";
+export type OutcomesData = Record<string, number>;
+export type ExperimentsData = Record<string, ExperimentData>;
+export interface ExperimentData {
+    totalWeight: number;
+    variants: VariantData[];
+}
+export interface VariantData {
+    name?: string;
+    weight: number;
+}

package/dist/_pkg/experiments/browser/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useExperiment.ts';

package/dist/_pkg/experiments/browser/hooks/useExperiment.d.ts

@@ -0,0 +1,6 @@
+import type { VariantData } from '../components/index.tsx';
+export declare const selectVariantForExperiment: <T>(name: string, variants: Record<string, T>, defaultValue: T) => T;
+export declare const useExperiments: <T>(name: string, experiments: VariantData[]) => {
+    experimentName: string;
+    selectVariant: (variants: Record<string, T>, defaultValue: T) => T;
+};

package/dist/_pkg/experiments/browser/index.d.ts

@@ -0,0 +1,3 @@
+export * from './components/index.ts';
+export * from './hooks/index.ts';
+export * from './lib/index.ts';