naive-ui 2.41.1 → 2.43.0

package/lib/heatmap/src/Rect.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vue_1 = require("vue");
+const _utils_1 = require("../../_utils");
+const Tooltip_1 = __importDefault(require("../../tooltip/src/Tooltip"));
+exports.default = (0, vue_1.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 = (0, vue_1.computed)(() => ({
+            '--n-rect-color': props.color
+        }));
+        const tooltipPropsRef = (0, vue_1.computed)(() => {
+            return typeof props.tooltip === 'object' ? props.tooltip : {};
+        });
+        const defaultTooltipContentRef = (0, vue_1.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 = ((0, vue_1.h)("div", { class: [
+                `${mergedClsPrefix}-heatmap-rect`,
+                loading && `${mergedClsPrefix}-heatmap-rect--loading`,
+                loading && this.loadingClass
+            ], style: [cssVars, style] }));
+        return tooltip === false || loading ? (triggerNode) : ((0, vue_1.h)(Tooltip_1.default, Object.assign({ trigger: "hover" }, tooltipProps), {
+            default: () => (0, _utils_1.resolveSlotWithTypedProps)(this.$slots.tooltip, data, () => [
+                (0, vue_1.h)("div", null, defaultTooltipContent)
+            ]),
+            trigger: () => triggerNode
+        }));
+    }
+});

package/lib/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/lib/heatmap/src/animationStyle.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLoadingStyleClass = useLoadingStyleClass;
+const vue3_ssr_1 = require("@css-render/vue3-ssr");
+const css_render_1 = require("css-render");
+const vue_1 = require("vue");
+const cssr_1 = require("../../_utils/cssr");
+const context_1 = require("../../config-provider/src/context");
+function useLoadingStyleClass(props, themeRef) {
+    const loadingClassRef = (0, vue_1.ref)('');
+    const adapter = (0, vue3_ssr_1.useSsrAdapter)();
+    const NConfigProvider = (0, vue_1.inject)(context_1.configProviderInjectionKey, null);
+    const styleMountTarget = NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.styleMountTarget;
+    (0, vue_1.onMounted)(() => {
+        (0, vue_1.watchEffect)(() => {
+            if (!props.loading) {
+                return;
+            }
+            const { self: { loadingColorStart, loadingColorEnd } } = themeRef.value;
+            const loadingColorHash = (0, css_render_1.hash)(loadingColorStart) + (0, css_render_1.hash)(loadingColorEnd);
+            const className = `heatmap-loading-${loadingColorHash}`;
+            const animationName = `heatmap-loading-animation-${loadingColorHash}`;
+            loadingClassRef.value = className;
+            const cnode = (0, cssr_1.c)([
+                (0, cssr_1.c)(`.${className}`, `
+          animation: 2s ${animationName} infinite cubic-bezier(0.36, 0, 0.64, 1);
+        `),
+                (0, cssr_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/lib/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/lib/heatmap/src/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/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/lib/heatmap/src/public-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/heatmap/src/styles/index.cssr.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const cssr_1 = require("../../../_utils/cssr");
+// 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
+exports.default = (0, cssr_1.c)([(0, cssr_1.cB)('heatmap', `
+ display: flex;
+ flex-direction: column;
+ max-width: fit-content;
+ font-size: var(--n-font-size);
+ `, [(0, cssr_1.cE)('content', `
+ display: block;
+ `), (0, cssr_1.cE)('calendar-table', `
+ border-collapse: separate;
+ border-spacing: var(--n-y-gap) var(--n-x-gap);
+ font-size: var(--n-font-size);
+ `), (0, cssr_1.cE)('week-header-cell', `
+ width: 27px;
+ padding: 0;
+ border: none;
+ font-size: var(--n-font-size);
+ `), (0, cssr_1.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);
+ `), (0, cssr_1.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);
+ `), (0, cssr_1.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);
+ `), (0, cssr_1.cE)('empty-cell', `
+ width: var(--n-rect-size);
+ height: var(--n-rect-size);
+ border-radius: var(--n-border-radius);
+ `), (0, cssr_1.cE)('footer', `
+ display: flex;
+ justify-content: space-between;
+ margin-left: 17px;
+ align-items: center;
+ margin-top: 8px;
+ &:has(> :only-child) {
+ justify-content: flex-end;
+ }
+ `), (0, cssr_1.cE)('indicator', `
+ display: flex;
+ align-items: center;
+ justify-content: flex-end;
+ `)]), (0, cssr_1.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);
+ `, [(0, cssr_1.cM)('loading', `
+ cursor: default;
+ background: var(--n-loading-color-start);
+ `)]), (0, cssr_1.cB)('heatmap-color-indicator', `
+ display: flex;
+ align-items: center;
+ justify-content: flex-end;
+ gap: 4px;
+ font-size: var(--n-font-size);
+ `, [(0, cssr_1.cE)('cells', `
+ display: flex;
+ gap: var(--n-x-gap);
+ `), (0, cssr_1.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);
+ `), (0, cssr_1.cE)('label', `
+ font-size: var(--n-font-size);
+ color: var(--n-text-color);
+ transition: color .3s var(--n-bezier);
+ `)])]);

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

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

package/lib/heatmap/src/styles/rtl.cssr.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const cssr_1 = require("../../../_utils/cssr");
+exports.default = (0, cssr_1.cB)('heatmap', [(0, cssr_1.cM)('rtl', `
+ direction: rtl;
+ `)]);

package/lib/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/lib/heatmap/src/theme.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.heatmapColorThemes = void 0;
+exports.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']
+};

package/lib/heatmap/src/utils/index.d.ts

@@ -0,0 +1,32 @@
+import type { DayRect } from '../interface';
+import type { HeatmapData, HeatmapDataItem, HeatmapFirstDayOfWeek } from '../public-types';
+/** get color by value/maxValue */
+export declare function calcColorByValue(colors: string[], value: number | null | undefined, maxValue: number): string;
+/**
+ * fill gaps for the given data
+ *
+ * fill gaps `[firstDate,lastDate]` with value `0`
+ *
+ * fill `[firstCalendarDate,firstDate]` and `[lastDate,lastCalendarDate]` with value `null` by default
+ *
+ * fill `[firstCalendarDate,firstDate]` with value `0` when `fillCalendarLeading` is `true`
+ */
+export declare function completeDataGaps(data: HeatmapData, firstDayOfWeek: HeatmapFirstDayOfWeek, fillCalendarLeading: boolean): HeatmapData;
+/**
+ * Create a DayRect object with position information
+ */
+export declare function createDayRect(item: HeatmapDataItem, calendarStartDate: number, weekStartOn: number, colors: string[], maxValue: number): DayRect;
+/**
+ * Create a sparse matrix from items with position information
+ */
+export declare function createSparseMatrix<T>(rows: number, items: T[], getRowIndex: (item: T) => number, getColIndex: (item: T) => number): T[][];
+/**
+ * This creates a 7x53 matrix (typical year layout) filled with loading cells
+ */
+export declare function createLoadingMatrix(firstDayOfWeek: HeatmapFirstDayOfWeek): DayRect[][];
+/**
+ * Generate heatmap data for mock purposes.
+ * This function generates random data and the result is not stable.
+ * @param range - 'recent' for last year, or a specific year number
+ */
+export declare function heatmapMockData(year?: 'recent' | number): HeatmapData;

package/lib/heatmap/src/utils/index.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcColorByValue = calcColorByValue;
+exports.completeDataGaps = completeDataGaps;
+exports.createDayRect = createDayRect;
+exports.createSparseMatrix = createSparseMatrix;
+exports.createLoadingMatrix = createLoadingMatrix;
+exports.heatmapMockData = heatmapMockData;
+const date_fns_1 = require("date-fns");
+const lodash_1 = require("lodash");
+/** get color by value/maxValue */
+function calcColorByValue(colors, value, maxValue) {
+    if (maxValue === 0 || value === null || value === undefined || value <= 0) {
+        return colors[0];
+    }
+    const ratio = Math.min(value / maxValue, 1);
+    const maxLevel = colors.length - 1;
+    const level = Math.min(Math.ceil(ratio * maxLevel), maxLevel);
+    return colors[level];
+}
+/**
+ * fill gaps for the given data
+ *
+ * fill gaps `[firstDate,lastDate]` with value `0`
+ *
+ * fill `[firstCalendarDate,firstDate]` and `[lastDate,lastCalendarDate]` with value `null` by default
+ *
+ * fill `[firstCalendarDate,firstDate]` with value `0` when `fillCalendarLeading` is `true`
+ */
+function completeDataGaps(data, firstDayOfWeek, fillCalendarLeading) {
+    const sortedData = [...data].sort((a, b) => a.timestamp - b.timestamp);
+    const firstDate = sortedData[0].timestamp;
+    const lastDate = sortedData[sortedData.length - 1].timestamp;
+    const firstCalendarDate = (0, date_fns_1.startOfWeek)(firstDate, {
+        weekStartsOn: firstDayOfWeek
+    });
+    const lastCalendarEndDate = (0, date_fns_1.endOfWeek)(lastDate, {
+        weekStartsOn: firstDayOfWeek
+    });
+    const dataMap = new Map(sortedData.map(d => [(0, date_fns_1.startOfDay)(d.timestamp).getTime(), d]));
+    const allCalendarDates = (0, date_fns_1.eachDayOfInterval)({
+        start: firstCalendarDate,
+        end: lastCalendarEndDate
+    });
+    const startDate = fillCalendarLeading ? firstCalendarDate : firstDate;
+    return allCalendarDates.map((date) => {
+        const key = (0, date_fns_1.startOfDay)(date).getTime();
+        const dateValue = dataMap.get(key);
+        if (dateValue) {
+            return dateValue;
+        }
+        const value = (0, date_fns_1.isWithinInterval)(date, { start: startDate, end: lastDate })
+            ? 0
+            : null;
+        return { timestamp: date.getTime(), value };
+    });
+}
+/**
+ * Create a DayRect object with position information
+ */
+function createDayRect(item, calendarStartDate, weekStartOn, colors, maxValue) {
+    const daysFromGridStart = (0, date_fns_1.differenceInCalendarDays)(item.timestamp, calendarStartDate);
+    const colIndex = Math.floor(daysFromGridStart / 7);
+    const dayOfWeek = (0, date_fns_1.getDay)(item.timestamp);
+    const rowIndex = (dayOfWeek - weekStartOn + 7) % 7;
+    return {
+        timestamp: item.timestamp,
+        value: item.value,
+        color: calcColorByValue(colors, item.value, maxValue),
+        dayOfWeek,
+        rowIndex,
+        colIndex
+    };
+}
+/**
+ * Create a sparse matrix from items with position information
+ */
+function createSparseMatrix(rows, items, getRowIndex, getColIndex) {
+    const groupedByRow = (0, lodash_1.groupBy)(items, getRowIndex);
+    return Array.from({ length: rows }, (_, rowIndex) => {
+        const rowData = groupedByRow[rowIndex] || [];
+        const row = [];
+        rowData.forEach((item) => {
+            row[getColIndex(item)] = item;
+        });
+        return row;
+    });
+}
+/**
+ * This creates a 7x53 matrix (typical year layout) filled with loading cells
+ */
+function createLoadingMatrix(firstDayOfWeek) {
+    const rows = 7;
+    const cols = 53;
+    const currentTimestamp = Date.now();
+    return Array.from({ length: rows }, (_, row) => Array.from({ length: cols }, (_, col) => ({
+        timestamp: currentTimestamp,
+        value: 0,
+        color: '#000000',
+        dayOfWeek: (firstDayOfWeek + row) % 7,
+        rowIndex: row,
+        colIndex: col
+    })));
+}
+/**
+ * Generate heatmap data for mock purposes.
+ * This function generates random data and the result is not stable.
+ * @param range - 'recent' for last year, or a specific year number
+ */
+function heatmapMockData(year) {
+    let start;
+    let end;
+    if (year === undefined || year === 'recent') {
+        end = new Date();
+        start = (0, date_fns_1.subYears)(end, 1);
+    }
+    else {
+        const _year = Number(year);
+        start = (0, date_fns_1.startOfYear)(new Date(_year, 0, 1));
+        end = (0, date_fns_1.endOfYear)(new Date(_year, 11, 31));
+    }
+    const allDays = (0, date_fns_1.eachDayOfInterval)({ start, end });
+    return allDays.map((day) => {
+        const dayOfWeek = day.getDay();
+        const isWeekend = dayOfWeek === 0 || dayOfWeek === 6;
+        if (isWeekend && Math.random() < 0.7) {
+            return { timestamp: day.getTime(), value: 0 };
+        }
+        if (!isWeekend && Math.random() < 0.15) {
+            return { timestamp: day.getTime(), value: 0 };
+        }
+        const value = Math.floor(Math.pow(Math.random(), 2) * 40) + 1;
+        return { timestamp: day.getTime(), value };
+    });
+}

package/lib/heatmap/styles/dark.d.ts

@@ -0,0 +1,3 @@
+import type { HeatmapTheme } from './light';
+declare const HeatmapDark: HeatmapTheme;
+export default HeatmapDark;

package/lib/heatmap/styles/dark.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("../../_styles/common");
+const light_1 = require("./light");
+const HeatmapDark = {
+    name: 'Heatmap',
+    common: common_1.commonDark,
+    self(vars) {
+        const lightSelf = (0, light_1.self)(vars);
+        return Object.assign(Object.assign({}, lightSelf), { activeColors: ['#0d4429', '#006d32', '#26a641', '#39d353'], mininumColor: 'rgba(255, 255, 255, 0.1)', loadingColorStart: 'rgba(255, 255, 255, 0.12)', loadingColorEnd: 'rgba(255, 255, 255, 0.18)' });
+    }
+};
+exports.default = HeatmapDark;

package/lib/heatmap/styles/index.d.ts

@@ -0,0 +1,3 @@
+export { default as heatmapDark } from './dark';
+export { default as heatmapLight } from './light';
+export type { HeatmapTheme, HeatmapThemeVars } from './light';

package/lib/heatmap/styles/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.heatmapLight = exports.heatmapDark = void 0;
+var dark_1 = require("./dark");
+Object.defineProperty(exports, "heatmapDark", { enumerable: true, get: function () { return __importDefault(dark_1).default; } });
+var light_1 = require("./light");
+Object.defineProperty(exports, "heatmapLight", { enumerable: true, get: function () { return __importDefault(light_1).default; } });

package/lib/heatmap/styles/light.d.ts

@@ -0,0 +1,31 @@
+import type { ThemeCommonVars } from '../../_styles/common';
+import { type Theme } from '../../_mixins';
+export declare function self(vars: ThemeCommonVars): {
+    activeColors: string[];
+    borderRadius: string;
+    borderColor: string;
+    textColor: string;
+    mininumColor: string;
+    fontWeight: string;
+    loadingColorStart: string;
+    loadingColorEnd: string;
+    rectSizeSmall: string;
+    rectSizeMedium: string;
+    rectSizeLarge: string;
+    borderRadiusSmall: string;
+    borderRadiusMedium: string;
+    borderRadiusLarge: string;
+    xGapSmall: string;
+    xGapMedium: string;
+    xGapLarge: string;
+    yGapSmall: string;
+    yGapMedium: string;
+    yGapLarge: string;
+    fontSizeSmall: string;
+    fontSizeMedium: string;
+    fontSizeLarge: string;
+};
+export type HeatmapThemeVars = ReturnType<typeof self>;
+declare const heatmapLight: Theme<'Heatmap', HeatmapThemeVars>;
+export default heatmapLight;
+export type HeatmapTheme = typeof heatmapLight;

package/lib/heatmap/styles/light.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.self = self;
+const _mixins_1 = require("../../_mixins");
+const common_1 = require("../../_styles/common");
+function self(vars) {
+    const { borderRadius, fontSizeMini, fontSizeTiny, fontSizeSmall, fontWeight, textColor2, cardColor, buttonColor2Hover } = vars;
+    return {
+        activeColors: ['#9be9a8', '#40c463', '#30a14e', '#216e39'],
+        borderRadius,
+        borderColor: cardColor,
+        textColor: textColor2,
+        mininumColor: buttonColor2Hover,
+        fontWeight,
+        loadingColorStart: 'rgba(0, 0, 0, 0.06)',
+        loadingColorEnd: 'rgba(0, 0, 0, 0.12)',
+        rectSizeSmall: '10px',
+        rectSizeMedium: '11px',
+        rectSizeLarge: '12px',
+        borderRadiusSmall: '2px',
+        borderRadiusMedium: '2px',
+        borderRadiusLarge: '2px',
+        xGapSmall: '2px',
+        xGapMedium: '3px',
+        xGapLarge: '3px',
+        yGapSmall: '2px',
+        yGapMedium: '3px',
+        yGapLarge: '3px',
+        fontSizeSmall: fontSizeTiny,
+        fontSizeMedium: fontSizeMini,
+        fontSizeLarge: fontSizeSmall
+    };
+}
+const heatmapLight = (0, _mixins_1.createTheme)({
+    name: 'Heatmap',
+    common: common_1.commonLight,
+    self
+});
+exports.default = heatmapLight;

package/lib/heatmap/styles/rtl.d.ts

@@ -0,0 +1,2 @@
+import type { RtlItem } from '../../config-provider/src/internal-interface';
+export declare const heatmapRtl: RtlItem;

package/lib/heatmap/styles/rtl.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.heatmapRtl = void 0;
+const rtl_cssr_1 = __importDefault(require("../src/styles/rtl.cssr"));
+exports.heatmapRtl = {
+    name: 'Heatmap',
+    style: rtl_cssr_1.default
+};

package/lib/highlight/src/utils.js

@@ -1,33 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitAndMarkByRegex = splitAndMarkByRegex;
-// Generated by ChatGPT
 function splitAndMarkByRegex(str, regex) {
+    if (!regex.global) {
+        throw new Error('splitAndMarkByRegex requires a global regex (with "g" flag)');
+    }
     const result = [];
     let lastIndex = 0;
-    let match;
-    // eslint-disable-next-line no-cond-assign
-    while ((match = regex.exec(str)) !== null) {
-        if (match.index > lastIndex) {
-            result.push({
-                text: str.slice(lastIndex, match.index),
-                isMatch: false
-            });
-        }
-        result.push({
-            text: match[0],
-            isMatch: true
-        });
-        lastIndex = regex.lastIndex;
-        if (!regex.global) {
-            break;
+    for (const match of str.matchAll(regex)) {
+        const { index } = match;
+        if (index > lastIndex) {
+            result.push({ text: str.slice(lastIndex, index), isMatch: false });
         }
+        result.push({ text: match[0], isMatch: true });
+        lastIndex = index + match[0].length;
     }
     if (lastIndex < str.length) {
-        result.push({
-            text: str.slice(lastIndex),
-            isMatch: false
-        });
+        result.push({ text: str.slice(lastIndex), isMatch: false });
     }
     return result;
 }

package/lib/icon/src/styles/index.cssr.js

@@ -16,7 +16,6 @@ exports.default = (0, cssr_1.cB)('icon', `
  display: inline-block;
  position: relative;
  fill: currentColor;
- transform: translateZ(0);
 `, [(0, cssr_1.cM)('color-transition', {
   transition: 'color .3s var(--n-bezier)'
 }), (0, cssr_1.cM)('depth', {

package/lib/image/index.d.ts

@@ -1,5 +1,7 @@
 export { imageProps, default as NImage } from './src/Image';
-export type { ImageProps, ImageSlots } from './src/Image';
+export type { ImageProps } from './src/Image';
 export { imageGroupProps, default as NImageGroup } from './src/ImageGroup';
 export type { ImageGroupProps } from './src/ImageGroup';
+export { imagePreviewProps, default as NImagePreview } from './src/ImagePreview';
+export type { ImagePreviewProps } from './src/ImagePreview';
 export type * from './src/public-types';