@ariestools/sdk-react 10.0.2

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

@@ -0,0 +1,331 @@
+// src/components/Experiment.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+var Experiment = (props) => {
+  const {
+    children,
+    key,
+    weight
+  } = props;
+  void key;
+  void weight;
+  return /* @__PURE__ */ jsx(Fragment, { children });
+};
+
+// src/components/Experiments.tsx
+import { forget } from "@ariestools/sdk";
+import { useUserEvents } from "../../pixel/browser/index.mjs";
+import { getLocalStorageObject, setLocalStorageObject } from "../../shared/browser/index.mjs";
+import { useState } from "react";
+
+// src/components/models/index.ts
+var OutcomesLocalStorageKey = "outcomes";
+var ExperimentsLocalStorageKey = "experiments";
+
+// src/components/Experiments.tsx
+var defaultLocalStorageKey = "testData";
+var experimentsTestData = {};
+var outcomes = {};
+var saveOutcomes = () => {
+  setLocalStorageObject(OutcomesLocalStorageKey, outcomes);
+};
+var saveExperimentsTestData = (key) => {
+  const mergeData = (data, log) => {
+    const dataArray = [];
+    for (const key2 in data) {
+      dataArray.push(`${key2}-${data[key2]}`);
+    }
+    log?.info("MergeData", dataArray.join("|"));
+    return dataArray.join("|");
+  };
+  localStorage.setItem(key, mergeData(experimentsTestData));
+};
+var loadOutcomes = () => {
+  outcomes = getLocalStorageObject(OutcomesLocalStorageKey) ?? {};
+};
+var loadExperimentsTestData = (key) => {
+  experimentsTestData = localStorage.getItem(key)?.split("|").reduce(
+    (acc, current) => {
+      const data = current.split("-");
+      acc[data[0]] = data[1];
+      return acc;
+    },
+    {}
+  ) ?? {};
+};
+var missingKeyError = new Error("Experiment Elements must have Keys");
+var makeChildrenArray = (children) => {
+  return Array.isArray(children) ? children : [children];
+};
+var buildLocalStorageKey = (localStorageProp) => {
+  return localStorageProp === true ? defaultLocalStorageKey : typeof localStorageProp === "string" ? localStorageProp ?? defaultLocalStorageKey : "";
+};
+var calcTotalWeight = (childList) => {
+  let totalWeight = 0;
+  for (const child of childList) {
+    totalWeight += child.props.weight;
+  }
+  return totalWeight;
+};
+var saveExperimentDebugRanges = (name, totalWeight, childList) => {
+  const experiments = getLocalStorageObject(ExperimentsLocalStorageKey) ?? {};
+  experiments[name] = {
+    totalWeight,
+    variants: childList.map((child) => ({
+      name: child.key?.toString(),
+      weight: child.props.weight
+    }))
+  };
+  setLocalStorageObject(ExperimentsLocalStorageKey, experiments);
+};
+var Experiments = (props) => {
+  const {
+    name,
+    children,
+    localStorageProp = true
+  } = props;
+  const userEvents = useUserEvents();
+  const [chosenChild] = useState(() => {
+    const localStorageKey = buildLocalStorageKey(localStorageProp);
+    const childList = makeChildrenArray(children);
+    const totalWeight = calcTotalWeight(childList);
+    loadOutcomes();
+    loadExperimentsTestData(localStorageKey);
+    saveExperimentDebugRanges(name, totalWeight, childList);
+    const firstTime = outcomes[name] === void 0;
+    let targetWeight = outcomes[name] ?? Math.random() * totalWeight;
+    outcomes[name] = targetWeight;
+    saveOutcomes();
+    for (const child of childList) {
+      targetWeight -= child.props.weight;
+      if (targetWeight > 0) continue;
+      if (child.key === null || child.key === void 0) {
+        throw missingKeyError;
+      }
+      experimentsTestData[name] = child.key.toString();
+      if (firstTime) {
+        if (localStorageProp !== false) {
+          saveExperimentsTestData(localStorageKey);
+        }
+        if (userEvents) {
+          forget(userEvents.testStarted({ name, variation: child.key }));
+        }
+      }
+      return child;
+    }
+    throw new Error("Experiment Choice Failed");
+  });
+  return chosenChild;
+};
+
+// src/components/ExperimentsDebugger.tsx
+import { FlexCol, FlexRow } from "../../flexbox/browser/index.mjs";
+import { useLocalStorage } from "../../shared/browser/index.mjs";
+import { Slider, Typography } from "@mui/material";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var ExperimentsDebugger = ({ ...props }) => {
+  const [experiments] = useLocalStorage(ExperimentsLocalStorageKey, {});
+  const [outcomes3, setOutcomes] = useLocalStorage(OutcomesLocalStorageKey, {});
+  const sumUpVariants = (items) => items.reduce((acc, curr) => acc + curr.weight, 0);
+  const experimentEntries = Object.entries(experiments);
+  if (experimentEntries.length === 0) {
+    return /* @__PURE__ */ jsxs(
+      FlexCol,
+      {
+        ...props,
+        sx: { alignItems: "stretch" },
+        children: [
+          /* @__PURE__ */ jsx2(Typography, { variant: "subtitle1", children: "No Experiments loaded" }),
+          /* @__PURE__ */ jsx2(Typography, { variant: "subtitle2", children: "Visit a page with an experiment to load the data" })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx2(
+    FlexCol,
+    {
+      ...props,
+      sx: { alignItems: "stretch" },
+      children: Object.entries(experiments).map((data) => {
+        const [name, experiment] = data;
+        const outcome = outcomes3[name] ?? 0;
+        const marks = [
+          { label: `${experiment.variants[0].name} | ${experiment.variants[0].weight}`, value: 0 },
+          ...experiment.variants.map(({ weight }, index) => ({
+            label: index === experiment.variants.length - 1 ? "End" : `${experiment.variants[index + 1].name} | ${weight}`,
+            value: index === 0 ? weight : sumUpVariants(experiment.variants.slice(0, index + 1))
+          }))
+        ];
+        return /* @__PURE__ */ jsxs(
+          FlexCol,
+          {
+            ...props,
+            sx: {
+              alignItems: "stretch",
+              paddingX: 4,
+              marginBottom: 4
+            },
+            children: [
+              /* @__PURE__ */ jsxs(FlexRow, { children: [
+                name,
+                ":\xA0",
+                outcome
+              ] }),
+              /* @__PURE__ */ jsx2(FlexRow, { children: /* @__PURE__ */ jsx2(
+                Slider,
+                {
+                  "aria-label": `Experiment ${name}`,
+                  defaultValue: outcome,
+                  value: outcome,
+                  marks,
+                  onChange: (_event, value) => {
+                    const truncated = Number((Array.isArray(value) ? value[0] : value).toFixed(2));
+                    outcomes3[name] = truncated;
+                    setOutcomes({ ...outcomes3 });
+                  }
+                }
+              ) })
+            ]
+          },
+          `experiment-${name}`
+        );
+      })
+    }
+  );
+};
+
+// src/hooks/useExperiment.ts
+import { useUserEvents as useUserEvents2 } from "../../pixel/browser/index.mjs";
+import { useState as useState2 } from "react";
+
+// src/lib/ExperimentsHelper.ts
+import { forget as forget2 } from "@ariestools/sdk";
+import { getLocalStorageObject as getLocalStorageObject2, setLocalStorageObject as setLocalStorageObject2 } from "../../shared/browser/index.mjs";
+var defaultLocalStorageKey2 = "testData";
+var experimentsTestData2 = {};
+var outcomes2 = {};
+var ExperimentsHelper = {
+  buildLocalStorageKey: (localStorageProp) => {
+    return localStorageProp === true ? defaultLocalStorageKey2 : typeof localStorageProp === "string" ? localStorageProp ?? defaultLocalStorageKey2 : "";
+  },
+  calcTotalWeight: (variants) => {
+    return variants.reduce((sum, variant) => {
+      return sum + variant.weight;
+    }, 0);
+  },
+  calculateExperiment: (name, localStorageProp, variants, userEvents) => {
+    const localStorageKey = ExperimentsHelper.buildLocalStorageKey(localStorageProp);
+    const totalWeight = ExperimentsHelper.calcTotalWeight(variants);
+    ExperimentsHelper.loadOutcomes();
+    ExperimentsHelper.loadExperimentsTestData(localStorageKey);
+    ExperimentsHelper.saveExperimentRanges(name, totalWeight, variants);
+    const firstTime = !Object.hasOwn(outcomes2, name);
+    let targetWeight = outcomes2[name] ?? Math.random() * totalWeight;
+    outcomes2[name] = targetWeight;
+    ExperimentsHelper.saveOutcomes();
+    for (const variant of variants) {
+      targetWeight -= variant.weight;
+      if (targetWeight > 0) continue;
+      if (variant.name === void 0 || variant.name === "") {
+        throw new Error("Experiment Elements must have Keys");
+      }
+      experimentsTestData2[name] = variant.name;
+      if (firstTime) {
+        ExperimentsHelper.saveExperimentsTestData(localStorageKey);
+      }
+      if (firstTime) {
+        forget2(userEvents.testStarted({ name, variation: variant.name }));
+      }
+      return variant;
+    }
+  },
+  getExperiment: (name) => {
+    ExperimentsHelper.loadOutcomes();
+    const experiments = getLocalStorageObject2(ExperimentsLocalStorageKey) ?? {};
+    return experiments[name];
+  },
+  getSelectedVariant: (name) => {
+    const outcomes3 = ExperimentsHelper.loadOutcomes();
+    const experiment = ExperimentsHelper.getExperiment(name);
+    let total = 0;
+    if (experiment !== void 0) {
+      const targetWeight = outcomes3[name];
+      for (const variant of experiment.variants) {
+        total += variant.weight;
+        if (total >= targetWeight) {
+          return variant;
+        }
+      }
+    }
+  },
+  loadExperimentsTestData: (key) => {
+    experimentsTestData2 = localStorage.getItem(key)?.split("|").reduce(
+      (acc, current) => {
+        const data = current.split("-");
+        acc[data[0]] = data[1];
+        return acc;
+      },
+      {}
+    ) ?? {};
+  },
+  loadOutcomes: () => {
+    outcomes2 = getLocalStorageObject2(OutcomesLocalStorageKey) ?? {};
+    return outcomes2;
+  },
+  saveExperimentRanges: (name, totalWeight, variants) => {
+    const experiments = getLocalStorageObject2(ExperimentsLocalStorageKey) ?? {};
+    experiments[name] = {
+      totalWeight,
+      variants
+    };
+    setLocalStorageObject2(ExperimentsLocalStorageKey, experiments);
+    return experiments;
+  },
+  saveExperimentsTestData: (key) => {
+    const mergeData = (data, log) => {
+      const dataArray = [];
+      for (const key2 in data) {
+        dataArray.push(`${key2}-${data[key2]}`);
+      }
+      log?.info("MergeData", dataArray.join("|"));
+      return dataArray.join("|");
+    };
+    localStorage.setItem(key, mergeData(experimentsTestData2));
+  },
+  saveOutcomes: () => {
+    setLocalStorageObject2(OutcomesLocalStorageKey, outcomes2);
+  }
+};
+
+// src/hooks/useExperiment.ts
+var selectVariant = (current) => (variants, defaultValue) => {
+  if (current !== void 0 && current !== "" && Object.hasOwn(variants, current)) {
+    return variants[current];
+  }
+  return defaultValue;
+};
+var selectVariantForExperiment = (name, variants, defaultValue) => {
+  const variant = ExperimentsHelper.getSelectedVariant(name);
+  const variantName = variant?.name;
+  if (variantName !== void 0 && variantName !== "" && Object.hasOwn(variants, variantName)) {
+    return variants[variantName];
+  }
+  return defaultValue;
+};
+var useExperiments = (name, experiments) => {
+  const userEvents = useUserEvents2(true);
+  const [activeExperiment] = useState2(() => ExperimentsHelper.calculateExperiment(name, true, experiments, userEvents));
+  return {
+    experimentName: name,
+    selectVariant: selectVariant(activeExperiment?.name)
+  };
+};
+export {
+  Experiment,
+  Experiments,
+  ExperimentsDebugger,
+  ExperimentsHelper,
+  ExperimentsLocalStorageKey,
+  OutcomesLocalStorageKey,
+  selectVariantForExperiment,
+  useExperiments
+};

package/dist/_pkg/experiments/browser/lib/ExperimentsHelper.d.ts

@@ -0,0 +1,16 @@
+import type { UserEventsProps } from '../../../pixel/browser/index.ts';
+import type { UserEventHandler } from '@xylabs/pixel';
+import type { ExperimentsData, OutcomesData, VariantData } from '../components/index.tsx';
+declare const ExperimentsHelper: {
+    buildLocalStorageKey: (localStorageProp: boolean | string) => string;
+    calcTotalWeight: (variants: VariantData[]) => number;
+    calculateExperiment: (name: string, localStorageProp: string | boolean, variants: VariantData[], userEvents: UserEventHandler<UserEventsProps>) => VariantData | undefined;
+    getExperiment: (name: string) => import("../index.ts").ExperimentData;
+    getSelectedVariant: (name: string) => VariantData | undefined;
+    loadExperimentsTestData: (key: string) => void;
+    loadOutcomes: () => OutcomesData;
+    saveExperimentRanges: (name: string, totalWeight: number, variants: VariantData[]) => ExperimentsData;
+    saveExperimentsTestData: (key: string) => void;
+    saveOutcomes: () => void;
+};
+export { ExperimentsHelper };

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

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

package/dist/_pkg/flexbox/browser/components/BusyBox/BusyBox.d.ts

@@ -0,0 +1,9 @@
+import type { BusyProps } from '../../../../shared/browser/index.ts';
+import type { BoxProps } from '@mui/material';
+import React from 'react';
+export type BusyBoxProps = BoxProps & BusyProps & {
+    background?: boolean;
+    paper?: boolean;
+};
+declare const BusyBox: React.FC<BusyBoxProps>;
+export { BusyBox };

package/dist/_pkg/flexbox/browser/components/BusyBox/index.d.ts

@@ -0,0 +1 @@
+export * from './BusyBox.tsx';

package/dist/_pkg/flexbox/browser/components/BusyCard.d.ts

@@ -0,0 +1,11 @@
+import type { BusyCircularProgressProps, BusyLinearProgressProps, BusyVariant } from '../../../shared/browser/index.ts';
+import type { CardProps } from '@mui/material';
+import type { PropsWithChildren } from 'react';
+import React from 'react';
+export interface BusyCardProps extends CardProps {
+    busy?: boolean;
+    busyMinimum?: number;
+    busyVariant?: BusyVariant;
+    busyVariantProps?: BusyCircularProgressProps | BusyLinearProgressProps;
+}
+export declare const BusyCard: React.FC<PropsWithChildren<BusyCardProps>>;

package/dist/_pkg/flexbox/browser/components/FlexBoxProps.d.ts

@@ -0,0 +1,2 @@
+import type { BusyBoxProps } from './BusyBox/index.ts';
+export type FlexBoxProps = BusyBoxProps;

package/dist/_pkg/flexbox/browser/components/FlexCol.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { FlexBoxProps } from './FlexBoxProps.tsx';
+declare const FlexCol: React.FC<FlexBoxProps>;
+declare const FlexGrowCol: React.FC<FlexBoxProps>;
+export { FlexCol, FlexGrowCol };

package/dist/_pkg/flexbox/browser/components/FlexRow.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { FlexBoxProps } from './FlexBoxProps.tsx';
+declare const FlexRow: React.FC<FlexBoxProps>;
+declare const FlexGrowRow: React.FC<FlexBoxProps>;
+export { FlexGrowRow, FlexRow };

package/dist/_pkg/flexbox/browser/components/HoverScale.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { FlexBoxProps } from './FlexBoxProps.tsx';
+export type HoverScaleProps = FlexBoxProps & {
+    scale?: number;
+};
+export declare const HoverScale: React.FC<HoverScaleProps>;

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

@@ -0,0 +1,6 @@
+export * from './BusyBox/index.ts';
+export * from './BusyCard.tsx';
+export * from './FlexBoxProps.tsx';
+export * from './FlexCol.tsx';
+export * from './FlexRow.tsx';
+export * from './HoverScale.tsx';

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

@@ -0,0 +1 @@
+export * from './useBusyTiming.tsx';

package/dist/_pkg/flexbox/browser/hooks/useBusyTiming.d.ts

@@ -0,0 +1 @@
+export declare const useBusyTiming: (busy?: boolean, busyMinimum?: number) => boolean;

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

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

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

@@ -0,0 +1,244 @@
+// src/components/BusyBox/BusyBox.tsx
+import { BusyCircularProgress, BusyLinearProgress } from "../../shared/browser/index.mjs";
+import {
+  Box,
+  Paper,
+  useTheme
+} from "@mui/material";
+
+// src/hooks/useBusyTiming.tsx
+import { delay } from "@ariestools/sdk";
+import { useAsyncEffect } from "../../async-effect/browser/index.mjs";
+import { useState } from "react";
+var useBusyTiming = (busy, busyMinimum = 0) => {
+  const [internalBusy, setInternalBusy] = useState(false);
+  const [busyStart, setBusyStart] = useState(0);
+  useAsyncEffect(
+    async (mounted) => {
+      if (mounted() && busyMinimum === 0) {
+        setInternalBusy(busy === true);
+        return;
+      }
+      const timer = {
+        evaluate: busy !== true && busyStart > 0,
+        initialize: busy === true && busyStart === 0,
+        terminated: busy !== true && busyStart === 0
+      };
+      const evaluateTimer = async (mounted2) => {
+        const busyDuration = Date.now() - busyStart;
+        if (busyDuration < busyMinimum) {
+          await delay(busyMinimum - busyDuration);
+          if (busy !== true && internalBusy && mounted2()) {
+            setBusyStart(0);
+            setInternalBusy(false);
+          }
+        } else if (mounted2()) {
+          setBusyStart(0);
+        }
+      };
+      if (busyMinimum > 0) {
+        const {
+          initialize,
+          evaluate,
+          terminated
+        } = timer;
+        if (initialize && mounted()) {
+          setBusyStart(Date.now());
+          setInternalBusy(true);
+          return;
+        }
+        if (evaluate) {
+          await evaluateTimer(mounted);
+          return;
+        }
+        if (terminated) {
+          setInternalBusy(false);
+          return;
+        }
+      }
+    },
+    [busy, busyStart, busyMinimum, internalBusy]
+  );
+  return internalBusy;
+};
+
+// src/components/BusyBox/BusyBox.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var BusyBox = ({
+  background,
+  children,
+  busyVariant = "circular",
+  busySize,
+  busyOpacity = 0.85,
+  busyColor,
+  busy,
+  busyCircularProps,
+  busyLinearProps,
+  busyMinimum = 0,
+  paper,
+  style,
+  sx,
+  ...props
+}) => {
+  const theme = useTheme();
+  const internalBusy = useBusyTiming(busy, busyMinimum);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      component: paper === true ? Paper : "div",
+      style: background === true ? {
+        backgroundColor: theme.vars.palette.background.default,
+        color: theme.vars.palette.text.primary,
+        ...style
+      } : style,
+      ...props,
+      sx: [{ position: "relative" }, ...toSxArray(sx)],
+      children: [
+        children,
+        internalBusy && busyVariant === "linear" ? /* @__PURE__ */ jsx(BusyLinearProgress, { color: busyColor, opacity: busyOpacity, ...busyLinearProps }) : null,
+        internalBusy && busyVariant === "circular" ? /* @__PURE__ */ jsx(BusyCircularProgress, { color: busyColor, opacity: busyOpacity, size: busySize, ...busyCircularProps }) : null
+      ]
+    }
+  );
+};
+var isSxArray = (sx) => Array.isArray(sx);
+var toSxArray = (sx) => sx === void 0 ? [] : isSxArray(sx) ? sx : [sx];
+BusyBox.displayName = "BusyBoxXYLabs";
+
+// src/components/BusyCard.tsx
+import {
+  BusyCircularProgress as BusyCircularProgress2,
+  BusyLinearProgress as BusyLinearProgress2
+} from "../../shared/browser/index.mjs";
+import { Card } from "@mui/material";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var BusyCard = ({
+  busy,
+  busyMinimum = 500,
+  busyVariant = "circular",
+  busyVariantProps,
+  children,
+  ...props
+}) => {
+  const internalBusy = useBusyTiming(busy, busyMinimum);
+  return /* @__PURE__ */ jsxs2(Card, { ...props, children: [
+    children,
+    busyVariant === "circular" && internalBusy ? /* @__PURE__ */ jsx2(BusyCircularProgress2, { ...busyVariantProps }) : null,
+    busyVariant === "linear" && internalBusy ? /* @__PURE__ */ jsx2(BusyLinearProgress2, { ...busyVariantProps }) : null
+  ] });
+};
+
+// src/components/FlexCol.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var isSxArray2 = (sx) => Array.isArray(sx);
+var toSxArray2 = (sx) => sx === void 0 ? [] : isSxArray2(sx) ? sx : [sx];
+var FlexCol = ({
+  ref,
+  sx,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx3(
+    BusyBox,
+    {
+      ref,
+      ...props,
+      sx: [{
+        alignItems: "center",
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center"
+      }, ...toSxArray2(sx)]
+    }
+  );
+};
+FlexCol.displayName = "FlexColXYLabs";
+var FlexGrowCol = ({
+  ref,
+  sx,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx3(
+    FlexCol,
+    {
+      ref,
+      ...props,
+      sx: [{ flexGrow: 1 }, ...toSxArray2(sx)]
+    }
+  );
+};
+FlexGrowCol.displayName = "FlexGrowColXYLabs";
+
+// src/components/FlexRow.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var isSxArray3 = (sx) => Array.isArray(sx);
+var toSxArray3 = (sx) => sx === void 0 ? [] : isSxArray3(sx) ? sx : [sx];
+var FlexRow = ({
+  ref,
+  sx,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx4(
+    BusyBox,
+    {
+      ref,
+      ...props,
+      sx: [{
+        alignItems: "center",
+        display: "flex",
+        flexDirection: "row",
+        justifyContent: "center"
+      }, ...toSxArray3(sx)]
+    }
+  );
+};
+FlexRow.displayName = "FlexRowXYLabs";
+var FlexGrowRow = ({
+  ref,
+  sx,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx4(
+    FlexRow,
+    {
+      ref,
+      ...props,
+      sx: [{ flexGrow: 1 }, ...toSxArray3(sx)]
+    }
+  );
+};
+FlexGrowRow.displayName = "FlexGrowRowXYLabs";
+
+// src/components/HoverScale.tsx
+import { Box as Box2 } from "@mui/material";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var HoverScale = ({
+  scale,
+  children,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx5(FlexRow, { ...props, children: /* @__PURE__ */ jsx5(
+    Box2,
+    {
+      sx: {
+        zoomdiv: {
+          "&:hover": {
+            transform: `scale(${scale})`,
+            transitionDuration: "0.2s",
+            transitionTimingFunction: "ease"
+          }
+        }
+      },
+      children
+    }
+  ) });
+};
+export {
+  BusyBox,
+  BusyCard,
+  FlexCol,
+  FlexGrowCol,
+  FlexGrowRow,
+  FlexRow,
+  HoverScale,
+  useBusyTiming
+};

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

@@ -0,0 +1,2 @@
+export * from './useResetState.ts';
+export * from './useUniversalRedirect.ts';