naive-ui 2.41.1 → 2.43.0

package/es/heatmap/src/Heatmap.mjs

@@ -0,0 +1,333 @@
+import { addDays, format, parseISO, startOfWeek } from 'date-fns';
+import { groupBy, mapValues, maxBy } from 'lodash';
+import { pxfy } from 'seemly';
+import { computed, defineComponent, h } from 'vue';
+import { useConfig, useLocale, useRtl, useTheme, useThemeClass } from "../../_mixins/index.mjs";
+import { createKey, resolveSlot, resolveWrappedSlot } from "../../_utils/index.mjs";
+import { transformNaiveFirstDayOfWeekToDateFns } from "../../date-picker/src/utils.mjs";
+import heatmapLight from "../styles/light.mjs";
+import { useLoadingStyleClass } from "./animationStyle.mjs";
+import HeatmapColorIndicator from "./ColorIndicator.mjs";
+import Rect from "./Rect.mjs";
+import style from "./styles/index.cssr.mjs";
+import { heatmapColorThemes } from "./theme.mjs";
+import { completeDataGaps, createDayRect, createLoadingMatrix, createSparseMatrix } from "./utils/index.mjs";
+export const heatmapProps = Object.assign(Object.assign({}, useTheme.props), {
+  activeColors: Array,
+  colorTheme: String,
+  data: Array,
+  loadingData: Object,
+  fillCalendarLeading: Boolean,
+  firstDayOfWeek: {
+    type: Number,
+    default: 0
+  },
+  loading: Boolean,
+  minimumColor: String,
+  showColorIndicator: {
+    type: Boolean,
+    default: true
+  },
+  showWeekLabels: {
+    type: Boolean,
+    default: true
+  },
+  showMonthLabels: {
+    type: Boolean,
+    default: true
+  },
+  size: {
+    type: String,
+    default: 'medium'
+  },
+  tooltip: {
+    type: [Boolean, Object],
+    default: false
+  },
+  xGap: [Number, String],
+  yGap: [Number, String]
+});
+export default defineComponent({
+  name: 'Heatmap',
+  slots: Object,
+  props: heatmapProps,
+  setup(props) {
+    const {
+      mergedClsPrefixRef,
+      mergedRtlRef,
+      inlineThemeDisabled
+    } = useConfig(props);
+    const {
+      localeRef,
+      dateLocaleRef
+    } = useLocale('Heatmap');
+    const themeRef = useTheme('Heatmap', '-heatmap', style, heatmapLight, props, mergedClsPrefixRef);
+    const rtlEnabledRef = useRtl('Heatmap', mergedRtlRef, mergedClsPrefixRef);
+    const cssVarsRef = computed(() => {
+      const {
+        xGap,
+        yGap,
+        size
+      } = props;
+      const {
+        common: {
+          cubicBezierEaseInOut
+        },
+        self: {
+          fontWeight,
+          textColor,
+          borderColor,
+          loadingColorStart,
+          [createKey('rectSize', size)]: rectSize,
+          [createKey('borderRadius', size)]: sizeBorderRadius,
+          [createKey('xGap', size)]: defaultXGap,
+          [createKey('yGap', size)]: defaultYGap,
+          [createKey('fontSize', size)]: fontSize
+        }
+      } = themeRef.value;
+      const cssVars = {
+        '--n-bezier': cubicBezierEaseInOut,
+        '--n-font-size': fontSize,
+        '--n-font-weight': fontWeight,
+        '--n-text-color': textColor,
+        '--n-border-radius': sizeBorderRadius,
+        '--n-border-color': borderColor,
+        '--n-loading-color-start': loadingColorStart,
+        '--n-rect-size': rectSize,
+        '--n-x-gap': xGap !== undefined ? typeof xGap === 'number' ? pxfy(xGap) : xGap : defaultXGap,
+        '--n-y-gap': yGap !== undefined ? typeof yGap === 'number' ? pxfy(yGap) : yGap : defaultYGap
+      };
+      return cssVars;
+    });
+    const themeClassHandle = inlineThemeDisabled ? useThemeClass('heatmap', computed(() => {
+      const {
+        size
+      } = props;
+      return size[0];
+    }), cssVarsRef, props) : undefined;
+    const mergedColorsRef = computed(() => {
+      const {
+        mininumColor: builtInMinimumColor,
+        activeColors: builtInActiveColors
+      } = themeRef.value.self;
+      const mergedMininumColor = props.minimumColor || builtInMinimumColor;
+      const theme = props.colorTheme && heatmapColorThemes[props.colorTheme];
+      const mergedActiveColors = props.activeColors || theme || builtInActiveColors;
+      return [mergedMininumColor, ...mergedActiveColors];
+    });
+    const normalizedDataRef = computed(() => {
+      if (!props.data || props.data.length === 0) {
+        return [];
+      }
+      return completeDataGaps(props.data, transformNaiveFirstDayOfWeekToDateFns(props.firstDayOfWeek), props.fillCalendarLeading);
+    });
+    const normalizedLoadingDataRef = computed(() => {
+      if (!props.loadingData || props.loadingData.length === 0) {
+        return [];
+      }
+      return completeDataGaps(props.loadingData, transformNaiveFirstDayOfWeekToDateFns(props.firstDayOfWeek), props.fillCalendarLeading);
+    });
+    const maxValueRef = computed(() => {
+      var _a, _b;
+      const validData = normalizedDataRef.value.filter(d => d.value !== null);
+      return (_b = (_a = maxBy(validData, d => d.value)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 0;
+    });
+    const heatmapMatrixRef = computed(() => {
+      const data = normalizedDataRef.value;
+      const loadingData = normalizedLoadingDataRef.value;
+      if (props.loading && !loadingData.length) {
+        return createLoadingMatrix(transformNaiveFirstDayOfWeekToDateFns(props.firstDayOfWeek));
+      }
+      const finalData = props.loading ? loadingData : data;
+      if (!finalData.length) return [];
+      const maxValue = maxValueRef.value;
+      const colors = mergedColorsRef.value;
+      const calendarStartDate = finalData[0].timestamp;
+      const dayRects = finalData.map(item => createDayRect(item, calendarStartDate, transformNaiveFirstDayOfWeekToDateFns(props.firstDayOfWeek), colors, maxValue));
+      return createSparseMatrix(7, dayRects, dayRect => dayRect.rowIndex, dayRect => dayRect.colIndex);
+    });
+    const weekLabelsRef = computed(() => {
+      const {
+        weekdayFormat
+      } = localeRef.value;
+      const {
+        locale
+      } = dateLocaleRef.value;
+      const baseDate = startOfWeek(new Date(), {
+        weekStartsOn: transformNaiveFirstDayOfWeekToDateFns(props.firstDayOfWeek)
+      });
+      return Array.from({
+        length: 7
+      }, (_, i) => {
+        return {
+          label: format(addDays(baseDate, i), weekdayFormat, {
+            locale
+          }),
+          visible: i % 2 !== 0
+        };
+      });
+    });
+    const loadingMonthLabelsRef = computed(() => {
+      const {
+        monthFormat
+      } = localeRef.value;
+      const {
+        locale
+      } = dateLocaleRef.value;
+      const currentYear = new Date().getFullYear();
+      // for more consistent month label widths
+      const colSpans = [5, 4, 5, 4, 5, 4, 5, 4, 4, 5, 4, 4];
+      return Array.from({
+        length: 12
+      }, (_, i) => {
+        const monthDate = new Date(currentYear, i, 1);
+        return {
+          name: format(monthDate, monthFormat, {
+            locale
+          }),
+          colSpan: colSpans[i]
+        };
+      });
+    });
+    function getColsMonth(matrix) {
+      const cols = matrix[0].length;
+      const res = [];
+      for (let col = 0; col < cols; col++) {
+        for (let row = 0; row < matrix.length; row++) {
+          const cell = matrix[row][col];
+          if ((cell === null || cell === void 0 ? void 0 : cell.value) !== null) {
+            res.push({
+              week: col,
+              month: format(cell.timestamp, 'yyyy-MM')
+            });
+            break;
+          }
+        }
+      }
+      return res;
+    }
+    const dataMonthLabelsRef = computed(() => {
+      const {
+        monthFormat
+      } = localeRef.value;
+      const {
+        locale
+      } = dateLocaleRef.value;
+      const matrix = heatmapMatrixRef.value;
+      if (!matrix || matrix.length === 0 || !matrix[0]) {
+        return [];
+      }
+      const colsWithMonth = getColsMonth(matrix);
+      const monthStats = mapValues(groupBy(colsWithMonth, 'month'), entries => {
+        const weekNumbers = entries.map(e => e.week);
+        return {
+          weekCount: entries.length,
+          start: Math.min(...weekNumbers),
+          end: Math.max(...weekNumbers)
+        };
+      });
+      return Object.entries(monthStats).filter(([, stats]) => stats.weekCount >= 3) // ensure have enough space
+      .sort(([a], [b]) => a.localeCompare(b)).map(([month, stats]) => {
+        const monthDate = new Date(parseISO(`${month}-01`));
+        return {
+          name: format(monthDate, monthFormat, {
+            locale
+          }),
+          colSpan: stats.end - stats.start + 1
+        };
+      });
+    });
+    const monthLabelsRef = computed(() => {
+      return props.loading && !props.loadingData ? loadingMonthLabelsRef.value : dataMonthLabelsRef.value;
+    });
+    const loadingClassRef = useLoadingStyleClass(props, themeRef);
+    return {
+      weekLabels: weekLabelsRef,
+      monthLabels: monthLabelsRef,
+      mergedColors: mergedColorsRef,
+      mergedClsPrefix: mergedClsPrefixRef,
+      rtlEnabled: rtlEnabledRef,
+      locale: localeRef,
+      cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
+      themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
+      onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender,
+      heatmapMatrix: heatmapMatrixRef,
+      loadingClass: loadingClassRef
+    };
+  },
+  render() {
+    const {
+      loading,
+      showWeekLabels,
+      showMonthLabels,
+      showColorIndicator,
+      mergedClsPrefix,
+      themeClass,
+      cssVars,
+      rtlEnabled,
+      locale,
+      weekLabels,
+      monthLabels,
+      mergedColors,
+      $slots,
+      heatmapMatrix,
+      loadingClass,
+      onRender
+    } = this;
+    onRender === null || onRender === void 0 ? void 0 : onRender();
+    return h("div", {
+      class: [themeClass, `${mergedClsPrefix}-heatmap`, rtlEnabled && `${mergedClsPrefix}-heatmap--rtl`],
+      style: cssVars
+    }, h("div", {
+      class: `${mergedClsPrefix}-heatmap__content`
+    }, h("table", {
+      class: `${mergedClsPrefix}-heatmap__calendar-table`
+    }, showMonthLabels && h("thead", null, h("tr", null, showWeekLabels && h("th", {
+      class: `${mergedClsPrefix}-heatmap__week-header-cell`
+    }), monthLabels.map((monthLabel, index) => h("th", {
+      key: `month-${index}`,
+      colspan: monthLabel.colSpan,
+      class: `${mergedClsPrefix}-heatmap__month-label-cell`
+    }, monthLabel.name)))), h("tbody", null, weekLabels.map((weekLabel, rowIdx) => {
+      return h("tr", {
+        key: `row-${rowIdx}`
+      }, showWeekLabels && h("td", {
+        class: `${mergedClsPrefix}-heatmap__week-label-cell`
+      }, weekLabel.visible ? weekLabel.label : null), (heatmapMatrix[rowIdx] || []).map((day, weekIdx) => {
+        return day.value !== null ? h("td", {
+          key: `day-${rowIdx}-${weekIdx}`,
+          class: `${mergedClsPrefix}-heatmap__day-cell`
+        }, h(Rect, {
+          mergedClsPrefix: mergedClsPrefix,
+          data: day,
+          color: day.color,
+          tooltip: this.tooltip,
+          loading: loading,
+          loadingClass: loadingClass
+        }, {
+          tooltip: () => {
+            var _a;
+            return (_a = $slots.tooltip) === null || _a === void 0 ? void 0 : _a.call($slots, day);
+          }
+        })) : h("td", {
+          key: `empty-${rowIdx}-${weekIdx}`,
+          class: `${mergedClsPrefix}-heatmap__day-cell`
+        }, h("div", {
+          class: `${mergedClsPrefix}-heatmap__empty-cell`
+        }));
+      }));
+    })))), h("div", {
+      class: `${mergedClsPrefix}-heatmap__footer`
+    }, resolveWrappedSlot($slots.footer, children => children && h("div", {
+      class: `${mergedClsPrefix}-heatmap__footer`
+    }, children)), h("div", {
+      class: `${mergedClsPrefix}-heatmap__indicator`
+    }, resolveSlot($slots.indicator, () => [showColorIndicator && h(HeatmapColorIndicator, {
+      colors: mergedColors,
+      clsPrefix: mergedClsPrefix
+    }, {
+      'leading-text': () => resolveSlot($slots['indicator-leading-text'], () => [locale.less]),
+      'trailing-text': () => resolveSlot($slots['indicator-trailing-text'], () => [locale.more])
+    })]))));
+  }
+});

package/es/heatmap/src/Rect.d.ts

@@ -0,0 +1,57 @@
+import type { PropType, SlotsType, VNode } from 'vue';
+import type { PopoverProps } from '../../popover/src/Popover';
+import type { HeatmapDataItem } from './public-types';
+export interface RectSlots {
+    tooltip?: (props: HeatmapDataItem) => VNode[];
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    mergedClsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    data: {
+        type: PropType<HeatmapDataItem>;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        required: true;
+    };
+    style: ObjectConstructor;
+    loading: BooleanConstructor;
+    loadingClass: StringConstructor;
+    tooltip: {
+        type: PropType<PopoverProps | boolean>;
+        default: boolean;
+    };
+}>, {
+    cssVars: import("vue").ComputedRef<{
+        '--n-rect-color': string;
+    }>;
+    tooltipProps: import("vue").ComputedRef<PopoverProps>;
+    defaultTooltipContent: import("vue").ComputedRef<string>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    mergedClsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    data: {
+        type: PropType<HeatmapDataItem>;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        required: true;
+    };
+    style: ObjectConstructor;
+    loading: BooleanConstructor;
+    loadingClass: StringConstructor;
+    tooltip: {
+        type: PropType<PopoverProps | boolean>;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    tooltip: boolean | PopoverProps;
+    loading: boolean;
+}, SlotsType<RectSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/es/heatmap/src/Rect.mjs

@@ -0,0 +1,67 @@
+import { computed, defineComponent, h } from 'vue';
+import { resolveSlotWithTypedProps } from "../../_utils/index.mjs";
+import Tooltip from "../../tooltip/src/Tooltip.mjs";
+export default defineComponent({
+  name: 'HeatmapRect',
+  slots: Object,
+  props: {
+    mergedClsPrefix: {
+      type: String,
+      required: true
+    },
+    data: {
+      type: Object,
+      required: true
+    },
+    color: {
+      type: String,
+      required: true
+    },
+    style: Object,
+    loading: Boolean,
+    loadingClass: String,
+    tooltip: {
+      type: [Boolean, Object],
+      default: true
+    }
+  },
+  setup(props) {
+    const cssVarsRef = computed(() => ({
+      '--n-rect-color': props.color
+    }));
+    const tooltipPropsRef = computed(() => {
+      return typeof props.tooltip === 'object' ? props.tooltip : {};
+    });
+    const defaultTooltipContentRef = computed(() => {
+      const date = new Date(props.data.timestamp).toLocaleDateString();
+      return props.data.value !== null ? `${date} ${props.data.value}` : date;
+    });
+    return {
+      cssVars: cssVarsRef,
+      tooltipProps: tooltipPropsRef,
+      defaultTooltipContent: defaultTooltipContentRef
+    };
+  },
+  render() {
+    const {
+      mergedClsPrefix,
+      style,
+      cssVars,
+      tooltip,
+      tooltipProps,
+      defaultTooltipContent,
+      loading,
+      data
+    } = this;
+    const triggerNode = h("div", {
+      class: [`${mergedClsPrefix}-heatmap-rect`, loading && `${mergedClsPrefix}-heatmap-rect--loading`, loading && this.loadingClass],
+      style: [cssVars, style]
+    });
+    return tooltip === false || loading ? triggerNode : h(Tooltip, Object.assign({
+      trigger: "hover"
+    }, tooltipProps), {
+      default: () => resolveSlotWithTypedProps(this.$slots.tooltip, data, () => [h("div", null, defaultTooltipContent)]),
+      trigger: () => triggerNode
+    });
+  }
+});

package/es/heatmap/src/animationStyle.d.ts

@@ -0,0 +1,6 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { MergedTheme, Theme } from '../../_mixins';
+import type { HeatmapThemeVars } from '../styles';
+export declare function useLoadingStyleClass(props: {
+    loading?: boolean;
+}, themeRef: ComputedRef<MergedTheme<Theme<'Heatmap', HeatmapThemeVars, any>>>): Ref<string>;

package/es/heatmap/src/animationStyle.mjs

@@ -0,0 +1,51 @@
+import { useSsrAdapter } from '@css-render/vue3-ssr';
+import { hash } from 'css-render';
+import { inject, onMounted, ref, watchEffect } from 'vue';
+import { c } from "../../_utils/cssr/index.mjs";
+import { configProviderInjectionKey } from "../../config-provider/src/context.mjs";
+export function useLoadingStyleClass(props, themeRef) {
+  const loadingClassRef = ref('');
+  const adapter = useSsrAdapter();
+  const NConfigProvider = inject(configProviderInjectionKey, null);
+  const styleMountTarget = NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.styleMountTarget;
+  onMounted(() => {
+    watchEffect(() => {
+      if (!props.loading) {
+        return;
+      }
+      const {
+        self: {
+          loadingColorStart,
+          loadingColorEnd
+        }
+      } = themeRef.value;
+      const loadingColorHash = hash(loadingColorStart) + hash(loadingColorEnd);
+      const className = `heatmap-loading-${loadingColorHash}`;
+      const animationName = `heatmap-loading-animation-${loadingColorHash}`;
+      loadingClassRef.value = className;
+      const cnode = c([c(`.${className}`, `
+          animation: 2s ${animationName} infinite cubic-bezier(0.36, 0, 0.64, 1);
+        `), c(`@keyframes ${animationName}`, `
+          0% {
+            background: ${loadingColorStart};
+          }
+          40% {
+            background: ${loadingColorEnd};
+          }
+          80% {
+            background: ${loadingColorStart};
+          }
+          100% {
+            background: ${loadingColorStart};
+          }
+        `)]);
+      // We don't unmount it since we didn't know its mount count
+      cnode.mount({
+        id: loadingColorHash,
+        ssr: adapter,
+        parent: styleMountTarget
+      });
+    });
+  });
+  return loadingClassRef;
+}

package/es/heatmap/src/interface.d.ts

@@ -0,0 +1,7 @@
+import type { HeatmapDataItem } from './public-types';
+export interface DayRect extends HeatmapDataItem {
+    color: string;
+    dayOfWeek: number;
+    rowIndex: number;
+    colIndex: number;
+}

package/es/heatmap/src/interface.mjs

@@ -0,0 +1 @@
+export {};

package/es/heatmap/src/public-types.d.ts

@@ -0,0 +1,16 @@
+import type { VNode } from 'vue';
+export type HeatmapData = HeatmapDataItem[];
+export interface HeatmapDataItem {
+    timestamp: number;
+    value?: number | null;
+}
+export type HeatmapTooltipSlotProps = HeatmapDataItem;
+export interface HeatmapSlots {
+    footer?: () => VNode[];
+    indicator?: () => VNode[];
+    'indicator-leading-text'?: () => VNode[];
+    'indicator-trailing-text'?: () => VNode[];
+    tooltip?: (props: HeatmapTooltipSlotProps) => VNode[];
+}
+export type HeatmapFirstDayOfWeek = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export type { HeatmapColorTheme } from './theme';

package/es/heatmap/src/public-types.mjs

@@ -0,0 +1 @@
+export {};

package/es/heatmap/src/styles/index.cssr.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("css-render").CNode;
+export default _default;

package/es/heatmap/src/styles/index.cssr.mjs

@@ -0,0 +1,102 @@
+import { c, cB, cE, cM } from "../../../_utils/cssr/index.mjs";
+// vars:
+// --n-font-size
+// --n-font-weight
+// --n-text-color
+// --n-border-radius
+// --n-x-gap
+// --n-y-gap
+// --n-rect-size
+// --n-rect-color (for individual rect background color)
+// --n-bezier
+export default c([cB('heatmap', `
+ display: flex;
+ flex-direction: column;
+ max-width: fit-content;
+ font-size: var(--n-font-size);
+ `, [cE('content', `
+ display: block;
+ `), cE('calendar-table', `
+ border-collapse: separate;
+ border-spacing: var(--n-y-gap) var(--n-x-gap);
+ font-size: var(--n-font-size);
+ `), cE('week-header-cell', `
+ width: 27px;
+ padding: 0;
+ border: none;
+ font-size: var(--n-font-size);
+ `), cE('month-label-cell', `
+ font-size: var(--n-font-size);
+ color: var(--n-text-color);
+ text-align: left;
+ height: 15px;
+ line-height: 15px;
+ font-weight: var(--n-font-weight);
+ padding: 0 2px 8px;
+ vertical-align: bottom;
+ transition: color .3s var(--n-bezier);
+ `), cE('week-label-cell', `
+ font-size: var(--n-font-size);
+ color: var(--n-text-color);
+ text-align: right;
+ width: 27px;
+ height: 11px;
+ line-height: 11px;
+ padding: 0 4px 0 0;
+ border: none;
+ vertical-align: middle;
+ white-space: nowrap;
+ font-weight: var(--n-font-weight);
+ transition: color .3s var(--n-bezier);
+ `), cE('day-cell', `
+ width: var(--n-rect-size);
+ height: var(--n-rect-size);
+ padding: 0;
+ border: none;
+ vertical-align: middle;
+ transition: color .3s var(--n-bezier);
+ `), cE('empty-cell', `
+ width: var(--n-rect-size);
+ height: var(--n-rect-size);
+ border-radius: var(--n-border-radius);
+ `), cE('footer', `
+ display: flex;
+ justify-content: space-between;
+ margin-left: 17px;
+ align-items: center;
+ margin-top: 8px;
+ &:has(> :only-child) {
+ justify-content: flex-end;
+ }
+ `), cE('indicator', `
+ display: flex;
+ align-items: center;
+ justify-content: flex-end;
+ `)]), cB('heatmap-rect', `
+ width: var(--n-rect-size);
+ height: var(--n-rect-size);
+ border-radius: var(--n-border-radius);
+ background-color: var(--n-rect-color);
+ transition: background-color .3s var(--n-bezier);
+ `, [cM('loading', `
+ cursor: default;
+ background: var(--n-loading-color-start);
+ `)]), cB('heatmap-color-indicator', `
+ display: flex;
+ align-items: center;
+ justify-content: flex-end;
+ gap: 4px;
+ font-size: var(--n-font-size);
+ `, [cE('cells', `
+ display: flex;
+ gap: var(--n-x-gap);
+ `), cE('cell', `
+ width: var(--n-rect-size);
+ height: var(--n-rect-size);
+ border-radius: var(--n-border-radius);
+ transition: background-color .3s var(--n-bezier);
+ `), cE('label', `
+ font-size: var(--n-font-size);
+ color: var(--n-text-color);
+ transition: color .3s var(--n-bezier);
+ `)])]);

package/es/heatmap/src/styles/rtl.cssr.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("css-render").CNode;
+export default _default;

package/es/heatmap/src/styles/rtl.cssr.mjs

@@ -0,0 +1,4 @@
+import { cB, cM } from "../../../_utils/cssr/index.mjs";
+export default cB('heatmap', [cM('rtl', `
+ direction: rtl;
+ `)]);

package/es/heatmap/src/theme.d.ts

@@ -0,0 +1,8 @@
+export declare const heatmapColorThemes: {
+    green: string[];
+    blue: string[];
+    orange: string[];
+    purple: string[];
+    red: string[];
+};
+export type HeatmapColorTheme = keyof typeof heatmapColorThemes;

package/es/heatmap/src/theme.mjs

@@ -0,0 +1,7 @@
+export const heatmapColorThemes = {
+  green: ['#c6e48b', '#7bc96f', '#239a3b', '#196127'],
+  blue: ['#c0e7ff', '#73b3ff', '#0969da', '#0550ae'],
+  orange: ['#fed7aa', '#fb923c', '#ea580c', '#c2410c'],
+  purple: ['#e9d5ff', '#c084fc', '#9333ea', '#7c3aed'],
+  red: ['#fecaca', '#f87171', '#dc2626', '#b91c1c']
+};