@gearbox-protocol/permissionless-ui 1.2.33 → 1.4.0

package/dist/cjs/configs/tailwind.config.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,82 +15,37 @@ var __copyProps = (to, from, except, desc) => {
   }
   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);
 var tailwind_config_exports = {};
 __export(tailwind_config_exports, {
-  default: () => tailwind_config_default
+  default: () => tailwind_config_default,
+  preset: () => import_tailwind_preset.preset
 });
 module.exports = __toCommonJS(tailwind_config_exports);
-var import_tailwindcss_animate = __toESM(require("tailwindcss-animate"));
+var import_tailwind_preset = require('./tailwind-preset.js');
 const tailwindConfig = {
-  darkMode: ["class"],
-  content: [
-    "./pages/**/*.{js,ts,jsx,tsx,mdx}",
-    "./components/**/*.{js,ts,jsx,tsx,mdx}",
-    "./app/**/*.{js,ts,jsx,tsx,mdx}"
-  ],
+  ...import_tailwind_preset.preset,
+  content: {
+    files: [
+      "./pages/**/*.{js,ts,jsx,tsx,mdx}",
+      "./components/**/*.{js,ts,jsx,tsx,mdx}",
+      "./app/**/*.{js,ts,jsx,tsx,mdx}",
+      "./src/**/*.{js,ts,jsx,tsx,mdx}"
+    ]
+  },
   theme: {
+    ...import_tailwind_preset.preset.theme,
     extend: {
-      colors: {
-        background: "hsl(var(--background))",
-        foreground: "hsl(var(--foreground))",
-        card: {
-          DEFAULT: "hsl(var(--card))",
-          foreground: "hsl(var(--card-foreground))"
-        },
-        popover: {
-          DEFAULT: "hsl(var(--popover))",
-          foreground: "hsl(var(--popover-foreground))"
-        },
-        primary: {
-          DEFAULT: "hsl(var(--primary))",
-          foreground: "hsl(var(--primary-foreground))"
-        },
-        secondary: {
-          DEFAULT: "hsl(var(--secondary))",
-          foreground: "hsl(var(--secondary-foreground))"
-        },
-        muted: {
-          DEFAULT: "hsl(var(--muted))",
-          foreground: "hsl(var(--muted-foreground))"
-        },
-        accent: {
-          DEFAULT: "hsl(var(--accent))",
-          foreground: "hsl(var(--accent-foreground))"
-        },
-        destructive: {
-          DEFAULT: "hsl(var(--destructive))",
-          foreground: "hsl(var(--destructive-foreground))"
-        },
-        border: "hsl(var(--border))",
-        input: "hsl(var(--input))",
-        ring: "hsl(var(--ring))",
-        chart: {
-          "1": "hsl(var(--chart-1))",
-          "2": "hsl(var(--chart-2))",
-          "3": "hsl(var(--chart-3))",
-          "4": "hsl(var(--chart-4))",
-          "5": "hsl(var(--chart-5))"
-        }
-      },
-      borderRadius: {
-        lg: "var(--radius)",
-        md: "calc(var(--radius) - 2px)",
-        sm: "calc(var(--radius) - 4px)"
-      },
+      ...import_tailwind_preset.preset.theme?.extend,
       fontFamily: {
+        ...import_tailwind_preset.preset.theme?.extend?.fontFamily,
         mono: ["var(--font-geist-mono)", "monospace"]
       }
     }
-  },
-  plugins: [import_tailwindcss_animate.default]
+  }
 };
 var tailwind_config_default = tailwindConfig;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  preset
+});

package/dist/cjs/configs/variants.js

@@ -0,0 +1,58 @@
+"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);
+var variants_exports = {};
+__export(variants_exports, {
+  interactiveVariants: () => interactiveVariants,
+  paddingVariants: () => paddingVariants,
+  sizeVariants: () => sizeVariants,
+  stateVariants: () => stateVariants
+});
+module.exports = __toCommonJS(variants_exports);
+const sizeVariants = {
+  xs: "text-xs",
+  sm: "text-sm",
+  default: "text-sm",
+  lg: "text-base",
+  xl: "text-lg"
+};
+const stateVariants = {
+  default: "",
+  error: "border-red-500 text-red-500 focus-visible:ring-red-500",
+  success: "border-green-500 text-green-500 focus-visible:ring-green-500",
+  warning: "border-yellow-500 text-yellow-500 focus-visible:ring-yellow-500"
+};
+const paddingVariants = {
+  none: "p-0",
+  xs: "p-2",
+  sm: "p-4",
+  default: "p-6",
+  lg: "p-8",
+  xl: "p-10"
+};
+const interactiveVariants = {
+  default: "transition-colors duration-200",
+  disabled: "opacity-50 cursor-not-allowed pointer-events-none"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  interactiveVariants,
+  paddingVariants,
+  sizeVariants,
+  stateVariants
+});

package/dist/cjs/hooks/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);
+__reExport(hooks_exports, require('./use-controllable-state.js'), module.exports);
+__reExport(hooks_exports, require('./use-debounce.js'), module.exports);
+__reExport(hooks_exports, require('./use-filter.js'), module.exports);
+__reExport(hooks_exports, require('./use-hf.js'), module.exports);
+__reExport(hooks_exports, require('./use-liquidation/index.js'), module.exports);
+__reExport(hooks_exports, require('./use-media-query.js'), module.exports);
+__reExport(hooks_exports, require('./use-previous.js'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./use-controllable-state.js'),
+  ...require('./use-debounce.js'),
+  ...require('./use-filter.js'),
+  ...require('./use-hf.js'),
+  ...require('./use-liquidation/index.js'),
+  ...require('./use-media-query.js'),
+  ...require('./use-previous.js')
+});

package/dist/cjs/hooks/use-controllable-state.js

@@ -0,0 +1,50 @@
+"use strict";
+"use client";
+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);
+var use_controllable_state_exports = {};
+__export(use_controllable_state_exports, {
+  useControllableState: () => useControllableState
+});
+module.exports = __toCommonJS(use_controllable_state_exports);
+var import_react = require("react");
+function useControllableState({
+  value: controlledValue,
+  defaultValue,
+  onChange
+}) {
+  const [uncontrolledValue, setUncontrolledValue] = (0, import_react.useState)(defaultValue);
+  const isControlled = controlledValue !== void 0;
+  const value = isControlled ? controlledValue : uncontrolledValue;
+  const setValue = (0, import_react.useCallback)(
+    (nextValue) => {
+      const setter = nextValue;
+      const value2 = typeof nextValue === "function" ? setter(uncontrolledValue) : nextValue;
+      if (!isControlled) {
+        setUncontrolledValue(value2);
+      }
+      onChange?.(value2);
+    },
+    [isControlled, onChange, uncontrolledValue]
+  );
+  return [value, setValue];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useControllableState
+});

package/dist/cjs/hooks/use-debounce.js

@@ -0,0 +1,68 @@
+"use strict";
+"use client";
+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);
+var use_debounce_exports = {};
+__export(use_debounce_exports, {
+  useDebounce: () => useDebounce,
+  useDebounceCall: () => useDebounceCall
+});
+module.exports = __toCommonJS(use_debounce_exports);
+var import_react = require("react");
+const debounce = (func, delay) => {
+  let timer = null;
+  const cleanup = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  const makeSyncTask = (arg) => () => {
+    func(arg);
+    cleanup();
+  };
+  const setTask = (arg) => {
+    cleanup();
+    timer = window.setTimeout(makeSyncTask(arg), delay);
+  };
+  return [setTask, cleanup];
+};
+function useDebounce(call, delay = 1e3) {
+  const [set, clean] = (0, import_react.useMemo)(() => debounce(call, delay), [call, delay]);
+  (0, import_react.useEffect)(() => {
+    return function cleanOnUnmount() {
+      clean();
+    };
+  }, [clean]);
+  return set;
+}
+const anyCall = (c) => c();
+function useDebounceCall(delay) {
+  const debounced = useDebounce(anyCall, delay);
+  return (0, import_react.useCallback)(
+    (call) => {
+      debounced(call);
+    },
+    [debounced]
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDebounce,
+  useDebounceCall
+});

package/dist/cjs/hooks/use-filter.js

@@ -0,0 +1,80 @@
+"use strict";
+"use client";
+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);
+var use_filter_exports = {};
+__export(use_filter_exports, {
+  getSortForField: () => getSortForField,
+  useFilterAllSelected: () => useFilterAllSelected,
+  useRangeFilter: () => useRangeFilter,
+  useSelectFilter: () => useSelectFilter,
+  useSort: () => useSort
+});
+module.exports = __toCommonJS(use_filter_exports);
+var import_react = require("react");
+function useRangeFilter() {
+  const [range, setRange] = (0, import_react.useState)(null);
+  const resetRange = (0, import_react.useCallback)(() => setRange(null), []);
+  return [range, setRange, resetRange];
+}
+function useSelectFilter(initialState = null) {
+  const [list, setList] = (0, import_react.useState)(initialState);
+  const resetList = (0, import_react.useCallback)(() => setList(null), []);
+  return [list, setList, resetList];
+}
+const getNextSortType = (s) => s === "asc" ? "desc" : "asc";
+const getSortForField = (s, state) => {
+  if (s !== state?.field) return void 0;
+  return state.sort;
+};
+function useSort(initialState = null) {
+  const [currentSort, setCurrentSort] = (0, import_react.useState)(
+    initialState
+  );
+  const sort = (0, import_react.useCallback)(
+    (field, startFromSort = "asc") => {
+      if (field === currentSort?.field) {
+        setCurrentSort({ field, sort: getNextSortType(currentSort.sort) });
+      } else {
+        setCurrentSort({ field, sort: startFromSort });
+      }
+    },
+    [currentSort]
+  );
+  return [currentSort, sort];
+}
+function useFilterAllSelected(filterState) {
+  const r = (0, import_react.useMemo)(() => {
+    return Object.values(filterState).reduce(
+      ([s, a], i) => {
+        const selected = !!i.state;
+        return [s || selected, a && selected];
+      },
+      [false, true]
+    );
+  }, [filterState]);
+  return r;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSortForField,
+  useFilterAllSelected,
+  useRangeFilter,
+  useSelectFilter,
+  useSort
+});

package/dist/cjs/hooks/use-hf.js

@@ -0,0 +1,62 @@
+"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);
+var use_hf_exports = {};
+__export(use_hf_exports, {
+  useHF: () => useHF
+});
+module.exports = __toCommonJS(use_hf_exports);
+var import_sdk = require("@gearbox-protocol/sdk");
+var import_react = require("react");
+function useHF({
+  assets,
+  quotas,
+  prices,
+  liquidationThresholds,
+  underlyingToken,
+  debt,
+  quotasInfo,
+  tokensList
+}) {
+  const hf = (0, import_react.useMemo)(() => {
+    return import_sdk.CreditAccountData_Legacy.calcHealthFactor({
+      assets,
+      quotas,
+      prices,
+      liquidationThresholds,
+      underlyingToken,
+      debt,
+      quotasInfo,
+      tokensList
+    });
+  }, [
+    assets,
+    quotas,
+    prices,
+    liquidationThresholds,
+    underlyingToken,
+    debt,
+    quotasInfo,
+    tokensList
+  ]);
+  return { hf };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useHF
+});

package/dist/cjs/hooks/use-liquidation/index.js

@@ -0,0 +1,204 @@
+"use strict";
+"use client";
+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);
+var use_liquidation_exports = {};
+__export(use_liquidation_exports, {
+  CELL_BAD: () => import_utils2.CELL_BAD,
+  CELL_CURRENT: () => import_utils2.CELL_CURRENT,
+  CELL_GOOD: () => import_utils2.CELL_GOOD,
+  CELL_HOVERED: () => import_utils2.CELL_HOVERED,
+  CELL_LIQUIDATION: () => import_utils2.CELL_LIQUIDATION,
+  CELL_OK: () => import_utils2.CELL_OK,
+  DEFAULT_AXIS_MAX: () => import_utils2.DEFAULT_AXIS_MAX,
+  DEFAULT_AXIS_MIN: () => import_utils2.DEFAULT_AXIS_MIN,
+  formatAxisLabel: () => import_utils2.formatAxisLabel,
+  formatAxisTipLabel: () => import_utils2.formatAxisTipLabel,
+  formatAxisTipPrice: () => import_utils2.formatAxisTipPrice,
+  getCellClass: () => import_utils2.getCellClass,
+  isPointInCell: () => import_utils2.isPointInCell,
+  useAxis: () => import_utils2.useAxis,
+  useEditPriceManually: () => useEditPriceManually,
+  useFixedAssets: () => import_utils2.useFixedAssets,
+  useIsAxisInRelativeUnits: () => import_utils2.useIsAxisInRelativeUnits,
+  useLiquidationGraphActivePrice: () => import_utils2.useLiquidationGraphActivePrice,
+  useLiquidationGraphCurrentActiveValue: () => import_utils2.useLiquidationGraphCurrentActiveValue,
+  useLiquidationGraphParams: () => useLiquidationGraphParams,
+  useLiquidationHeatmap: () => useLiquidationHeatmap,
+  usePriceInNumber: () => import_utils2.usePriceInNumber,
+  useWithLiquidationGraphActivePrices: () => import_utils2.useWithLiquidationGraphActivePrices
+});
+module.exports = __toCommonJS(use_liquidation_exports);
+var import_sdk = require("@gearbox-protocol/sdk");
+var import_react = require("react");
+var import_utils = require('./utils.js');
+var import_utils2 = require('./utils.js');
+const RESOLUTION = 35;
+function useLiquidationHeatmap({
+  xMin,
+  xMax,
+  yMin,
+  yMax,
+  xLabel,
+  yLabel,
+  assets,
+  quotas,
+  prices,
+  liquidationThresholds,
+  quotasInfo,
+  underlyingTokenAddress,
+  debt,
+  tokensList
+}) {
+  const heatmap = (0, import_react.useMemo)(() => {
+    const intervalX = xMax - xMin;
+    const intervalY = yMax - yMin;
+    const stepX = intervalX / RESOLUTION;
+    const stepY = intervalY / RESOLUTION;
+    const GRID = Array.from(Array(RESOLUTION));
+    const pricesCopy = { ...prices };
+    return GRID.flatMap((_, i) => {
+      const x = xMin + i * stepX;
+      const xEnd = xMin + (i + 1) * stepX;
+      if (xLabel) {
+        pricesCopy[xLabel.address] = (0, import_sdk.toBN)(
+          String((x + xEnd) / 2),
+          import_sdk.PRICE_DECIMALS_POW
+        );
+      }
+      return GRID.map((__, j) => {
+        const y = yMin + j * stepY;
+        const yEnd = yMin + (j + 1) * stepY;
+        if (yLabel) {
+          pricesCopy[yLabel.address] = (0, import_sdk.toBN)(
+            String((y + yEnd) / 2),
+            import_sdk.PRICE_DECIMALS_POW
+          );
+        }
+        return {
+          x,
+          xEnd,
+          y,
+          yEnd,
+          value: import_sdk.CreditAccountData_Legacy.calcHealthFactor({
+            assets,
+            quotas,
+            prices: pricesCopy,
+            liquidationThresholds,
+            underlyingToken: underlyingTokenAddress,
+            debt,
+            quotasInfo,
+            tokensList
+          })
+        };
+      });
+    });
+  }, [
+    xMin,
+    xMax,
+    yMin,
+    yMax,
+    xLabel,
+    yLabel,
+    assets,
+    quotas,
+    prices,
+    liquidationThresholds,
+    underlyingTokenAddress,
+    debt,
+    quotasInfo,
+    tokensList
+  ]);
+  return heatmap;
+}
+function useEditPriceManually({ prices }) {
+  const [editedPrices, setEditedPrices] = (0, import_react.useState)({});
+  const allPrices = (0, import_react.useMemo)(
+    () => ({ ...prices, ...editedPrices }),
+    [prices, editedPrices]
+  );
+  const handleEditPrice = (0, import_react.useCallback)(
+    (newPrice, token) => {
+      setEditedPrices({ ...editedPrices, [token]: newPrice });
+    },
+    [editedPrices]
+  );
+  return [allPrices, handleEditPrice];
+}
+function useLiquidationGraphParams({
+  assets,
+  liquidationThresholds,
+  quotas,
+  quotasInfo,
+  tokensList,
+  prices
+}) {
+  const [fixedBalances] = (0, import_utils.useFixedAssets)({
+    assets,
+    liquidationThresholds,
+    quotas,
+    quotasInfo
+  });
+  const [priceX, tokenX] = (0, import_utils.usePriceInNumber)({
+    asset: fixedBalances[0],
+    tokensList,
+    prices
+  });
+  const [priceY, tokenY] = (0, import_utils.usePriceInNumber)({
+    asset: fixedBalances[1],
+    tokensList,
+    prices
+  });
+  const xAxis = (0, import_utils.useAxis)({ currentPrice: priceX, token: tokenX });
+  const yAxis = (0, import_utils.useAxis)({ currentPrice: priceY, token: tokenY });
+  return {
+    xAxis,
+    yAxis,
+    currentPoint: [
+      priceX || import_utils.DEFAULT_AXIS_MAX / 2,
+      priceY || import_utils.DEFAULT_AXIS_MAX / 2
+    ],
+    fixedBalances
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CELL_BAD,
+  CELL_CURRENT,
+  CELL_GOOD,
+  CELL_HOVERED,
+  CELL_LIQUIDATION,
+  CELL_OK,
+  DEFAULT_AXIS_MAX,
+  DEFAULT_AXIS_MIN,
+  formatAxisLabel,
+  formatAxisTipLabel,
+  formatAxisTipPrice,
+  getCellClass,
+  isPointInCell,
+  useAxis,
+  useEditPriceManually,
+  useFixedAssets,
+  useIsAxisInRelativeUnits,
+  useLiquidationGraphActivePrice,
+  useLiquidationGraphCurrentActiveValue,
+  useLiquidationGraphParams,
+  useLiquidationHeatmap,
+  usePriceInNumber,
+  useWithLiquidationGraphActivePrices
+});

package/dist/cjs/hooks/use-liquidation/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);