niuma-ui 1.3.8 → 2.0.0

package/dist/components/time-picker/src/RsTimePickerColumns.js

@@ -0,0 +1,8 @@
+import './RsTimePickerColumns.css'
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.js";
+import RsTimePickerColumns_vue_vue_type_script_setup_true_lang_default from "./RsTimePickerColumns.impl.js";
+
+//#region src/components/time-picker/src/RsTimePickerColumns.vue
+var RsTimePickerColumns_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsTimePickerColumns_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-48197425"]]);
+//#endregion
+export { RsTimePickerColumns_default as default };

package/dist/components/time-picker/src/time-picker-utils.js

@@ -0,0 +1,158 @@
+//#region src/components/time-picker/src/time-picker-utils.ts
+var EMPTY_TIME_RANGE = {};
+var TIME_PATTERN = /^([01]\d|2[0-3]):([0-5]\d)$/;
+var TIME_WITH_SECONDS_PATTERN = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/;
+function scheduleAfterPaint(callback) {
+	let cancelled = false;
+	requestAnimationFrame(() => {
+		requestAnimationFrame(() => {
+			if (!cancelled) callback();
+		});
+	});
+	return () => {
+		cancelled = true;
+	};
+}
+function formatTimeUnitLabel(value) {
+	return String(value).padStart(2, "0");
+}
+function buildTimeUnitOptions(max, step = 1) {
+	const options = [];
+	for (let value = 0; value <= max; value += step) options.push({
+		value,
+		label: formatTimeUnitLabel(value)
+	});
+	return options;
+}
+/** 小时列固定选项 00–23 */
+var TIME_HOUR_OPTIONS = buildTimeUnitOptions(23);
+/** 秒列固定选项 00–59 */
+var TIME_SECOND_OPTIONS = buildTimeUnitOptions(59);
+var minuteOptionsCache = /* @__PURE__ */ new Map();
+/** 按步进缓存分钟列选项，默认 step=1 为 00–59 */
+function getTimeMinuteOptions(step = 1) {
+	const normalized = Math.max(1, Math.floor(step) || 1);
+	const cached = minuteOptionsCache.get(normalized);
+	if (cached) return cached;
+	const options = buildTimeUnitOptions(59, normalized);
+	minuteOptionsCache.set(normalized, options);
+	return options;
+}
+/**
+* 将时间列滚到指定 value，只改容器 scrollTop。
+* 避免 scrollIntoView 带动外层页面 / Popover 滚动。
+*/
+function scrollTimeColumnToValue(container, value) {
+	if (!container) return;
+	const item = container.querySelector(`:scope > [data-value="${value}"]`);
+	if (!item) return;
+	const top = item.offsetTop - (container.clientHeight - item.offsetHeight) / 2;
+	container.scrollTop = Math.max(0, top);
+}
+function parseTimeValue(value, withSeconds = false) {
+	if (!value?.trim()) return null;
+	const trimmed = value.trim();
+	if (withSeconds) {
+		const withSec = TIME_WITH_SECONDS_PATTERN.exec(trimmed);
+		if (withSec) return {
+			hour: Number.parseInt(withSec[1], 10),
+			minute: Number.parseInt(withSec[2], 10),
+			second: Number.parseInt(withSec[3], 10)
+		};
+		const minuteOnly = TIME_PATTERN.exec(trimmed);
+		if (minuteOnly) return {
+			hour: Number.parseInt(minuteOnly[1], 10),
+			minute: Number.parseInt(minuteOnly[2], 10),
+			second: 0
+		};
+		return null;
+	}
+	const match = TIME_PATTERN.exec(trimmed);
+	if (!match) return null;
+	return {
+		hour: Number.parseInt(match[1], 10),
+		minute: Number.parseInt(match[2], 10),
+		second: 0
+	};
+}
+function formatTimeParts(hour, minute, second) {
+	const h = String(hour).padStart(2, "0");
+	const m = String(minute).padStart(2, "0");
+	if (second !== void 0) return `${h}:${m}:${String(second).padStart(2, "0")}`;
+	return `${h}:${m}`;
+}
+function formatTimeFromParts(hour, minute, second, withSeconds = false) {
+	return formatTimeParts(hour, minute, withSeconds ? second : void 0);
+}
+function getCurrentTime() {
+	const now = /* @__PURE__ */ new Date();
+	return {
+		hour: now.getHours(),
+		minute: now.getMinutes(),
+		second: now.getSeconds()
+	};
+}
+function formatTimeValue(value) {
+	return value ?? "";
+}
+function timeToSeconds(hour, minute, second = 0) {
+	return hour * 3600 + minute * 60 + second;
+}
+function parseTimeToSeconds(value, withSeconds = false) {
+	const parsed = parseTimeValue(value, withSeconds);
+	if (!parsed) return null;
+	return timeToSeconds(parsed.hour, parsed.minute, parsed.second);
+}
+function isTimeWithinBounds(hour, minute, second, options = {}) {
+	const { minTime, maxTime, withSeconds = false } = options;
+	const candidate = timeToSeconds(hour, minute, second);
+	if (minTime) {
+		const minSeconds = parseTimeToSeconds(minTime, withSeconds);
+		if (minSeconds !== null && candidate < minSeconds) return false;
+	}
+	if (maxTime) {
+		const maxSeconds = parseTimeToSeconds(maxTime, withSeconds);
+		if (maxSeconds !== null && candidate > maxSeconds) return false;
+	}
+	return true;
+}
+function isTimeRangeEmpty(value) {
+	return !value.start?.trim() && !value.end?.trim();
+}
+function isTimeRangeOrdered(range, withSeconds = false) {
+	if (!range.start || !range.end) return true;
+	return isTimeRangeOrderedValues(range.start, range.end, withSeconds);
+}
+function isTimeRangeOrderedValues(start, end, withSeconds = false) {
+	const startSeconds = parseTimeToSeconds(start, withSeconds);
+	const endSeconds = parseTimeToSeconds(end, withSeconds);
+	if (startSeconds === null || endSeconds === null) return true;
+	return startSeconds <= endSeconds;
+}
+function pickEarlierTime(a, b, withSeconds = false) {
+	if (!a) return b;
+	if (!b) return a;
+	const ta = parseTimeToSeconds(a, withSeconds);
+	const tb = parseTimeToSeconds(b, withSeconds);
+	if (ta === null) return b;
+	if (tb === null) return a;
+	return ta <= tb ? a : b;
+}
+function pickLaterTime(a, b, withSeconds = false) {
+	if (!a) return b;
+	if (!b) return a;
+	const ta = parseTimeToSeconds(a, withSeconds);
+	const tb = parseTimeToSeconds(b, withSeconds);
+	if (ta === null) return b;
+	if (tb === null) return a;
+	return ta >= tb ? a : b;
+}
+function formatTimeRangeDisplay(range, options) {
+	const separator = options?.separator ?? " ~ ";
+	const start = range.start ? formatTimeValue(range.start) : "";
+	const end = range.end ? formatTimeValue(range.end) : "";
+	if (start && end) return `${start}${separator}${end}`;
+	return start || end;
+}
+//#endregion
+export { EMPTY_TIME_RANGE, TIME_HOUR_OPTIONS, TIME_SECOND_OPTIONS, formatTimeFromParts, formatTimeParts, formatTimeRangeDisplay, formatTimeUnitLabel, formatTimeValue, getCurrentTime, getTimeMinuteOptions, isTimeRangeEmpty, isTimeRangeOrdered, isTimeRangeOrderedValues, isTimeWithinBounds, parseTimeToSeconds, parseTimeValue, pickEarlierTime, pickLaterTime, scheduleAfterPaint, scrollTimeColumnToValue, timeToSeconds };

package/dist/components/time-picker/src/time-range-validation.js

@@ -0,0 +1,15 @@
+import { isTimeRangeOrdered } from "./time-picker-utils.js";
+//#region src/components/time-picker/src/time-range-validation.ts
+function validateTimeRangeValue(value, rules = {}) {
+	if (rules.required && (!value.start || !value.end)) return {
+		valid: false,
+		error: "required"
+	};
+	if (rules.ordered !== false && !isTimeRangeOrdered(value)) return {
+		valid: false,
+		error: "order"
+	};
+	return { valid: true };
+}
+//#endregion
+export { validateTimeRangeValue };

package/dist/components/time-picker/src/time-validation.js

@@ -0,0 +1,22 @@
+//#region src/components/time-picker/src/time-validation.ts
+function validateTimeValue(value, rules = {}) {
+	if (!value) return rules.required ? {
+		valid: false,
+		error: "required"
+	} : { valid: true };
+	if (!/^\d{2}:\d{2}(?::\d{2})?$/.test(value)) return {
+		valid: false,
+		error: "format"
+	};
+	if (rules.min && value < rules.min) return {
+		valid: false,
+		error: "min"
+	};
+	if (rules.max && value > rules.max) return {
+		valid: false,
+		error: "max"
+	};
+	return { valid: true };
+}
+//#endregion
+export { validateTimeValue };

package/dist/components/toaster/index.d.ts

@@ -0,0 +1 @@
+export { default as RsToaster } from './src/RsToaster.js';

package/dist/components/toaster/src/RsToaster.d.ts

@@ -0,0 +1,17 @@
+import type { RsToastPosition } from '../../_shared/src/overlay-utils';
+type __VLS_Props = {
+    position?: RsToastPosition;
+    closeButton?: boolean;
+    richColors?: boolean;
+    expand?: boolean;
+    gap?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    gap: number;
+    position: RsToastPosition;
+    expand: boolean;
+    closeButton: boolean;
+    richColors: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/toaster/src/RsToaster.impl.js

@@ -0,0 +1,67 @@
+import { rsConfigKey } from "../../../composables/useRsConfig.js";
+import { RS_TOAST_DEFAULT_POSITION } from "../../_shared/src/overlay-utils.js";
+import { Teleport, computed, createBlock, createVNode, defineComponent, inject, openBlock, unref } from "vue";
+import { Toaster } from "vue-sonner";
+//#region src/components/toaster/src/RsToaster.vue?vue&type=script&setup=true&lang.ts
+var RsToaster_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "RsToaster",
+	props: {
+		position: { default: RS_TOAST_DEFAULT_POSITION },
+		closeButton: {
+			type: Boolean,
+			default: true
+		},
+		richColors: {
+			type: Boolean,
+			default: false
+		},
+		expand: {
+			type: Boolean,
+			default: true
+		},
+		gap: { default: 4 }
+	},
+	setup(__props) {
+		const config = inject(rsConfigKey, null);
+		const sonnerTheme = computed(() => {
+			if (config?.theme.value) return config.theme.value === "dark" ? "dark" : "light";
+			if (typeof document !== "undefined") {
+				const mode = document.documentElement.dataset.rsTheme;
+				if (mode === "dark" || mode === "light") return mode;
+			}
+			return "dark";
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Teleport, { to: "body" }, [createVNode(unref(Toaster), {
+				theme: sonnerTheme.value,
+				position: __props.position,
+				"close-button": __props.closeButton,
+				expand: __props.expand,
+				gap: __props.gap,
+				"close-button-position": "top-right",
+				"rich-colors": __props.richColors,
+				class: "rs-toaster",
+				"toast-options": {
+					unstyled: true,
+					classes: {
+						toast: "rs-toast",
+						title: "rs-toast__title",
+						description: "rs-toast__description",
+						closeButton: "rs-toast__close",
+						actionButton: "rs-toast__action",
+						cancelButton: "rs-toast__action rs-toast__action--secondary"
+					}
+				}
+			}, null, 8, [
+				"theme",
+				"position",
+				"close-button",
+				"expand",
+				"gap",
+				"rich-colors"
+			])]);
+		};
+	}
+});
+//#endregion
+export { RsToaster_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/toaster/src/RsToaster.js

@@ -0,0 +1,7 @@
+import './RsToaster.css'
+import RsToaster_vue_vue_type_script_setup_true_lang_default from "./RsToaster.impl.js";
+
+//#region src/components/toaster/src/RsToaster.vue
+var RsToaster_default = RsToaster_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { RsToaster_default as default };

package/dist/components/toolbar/index.d.ts

@@ -0,0 +1,2 @@
+export { default as RsToolbar } from './src/RsToolbar.js';
+export type { RsToolbarBorder, RsToolbarSize } from './src/RsToolbar.js';

package/dist/components/toolbar/src/RsToolbar.impl.js

@@ -0,0 +1,57 @@
+import { createBlock, createCommentVNode, createElementBlock, defineComponent, normalizeClass, openBlock, renderSlot, resolveDynamicComponent, withCtx } from "vue";
+//#region src/components/toolbar/src/RsToolbar.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 0,
+	class: "rs-toolbar__start"
+};
+var _hoisted_2 = {
+	key: 1,
+	class: "rs-toolbar__center"
+};
+var _hoisted_3 = {
+	key: 2,
+	class: "rs-toolbar__end"
+};
+var RsToolbar_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "RsToolbar",
+	props: {
+		tag: { default: "header" },
+		size: { default: "md" },
+		border: { default: "bottom" },
+		elevated: {
+			type: Boolean,
+			default: false
+		},
+		compact: {
+			type: Boolean,
+			default: false
+		},
+		label: {}
+	},
+	setup(__props) {
+		/** 工具栏高度密度，对应常见面板顶栏。 */
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.tag), {
+				class: normalizeClass(["rs-toolbar", [
+					`rs-toolbar--${__props.size}`,
+					`rs-toolbar--border-${__props.border}`,
+					{
+						"rs-toolbar--elevated": __props.elevated,
+						"rs-toolbar--compact": __props.compact
+					}
+				]]),
+				role: "toolbar",
+				"aria-label": __props.label
+			}, {
+				default: withCtx(() => [
+					_ctx.$slots.left || _ctx.$slots.default ? (openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "left"), renderSlot(_ctx.$slots, "default")])) : createCommentVNode("", true),
+					_ctx.$slots.center ? (openBlock(), createElementBlock("div", _hoisted_2, [renderSlot(_ctx.$slots, "center")])) : createCommentVNode("", true),
+					_ctx.$slots.right ? (openBlock(), createElementBlock("div", _hoisted_3, [renderSlot(_ctx.$slots, "right")])) : createCommentVNode("", true)
+				]),
+				_: 3
+			}, 8, ["class", "aria-label"]);
+		};
+	}
+});
+//#endregion
+export { RsToolbar_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/toolbar/src/RsToolbar.js

@@ -0,0 +1,7 @@
+import './RsToolbar.css'
+import RsToolbar_vue_vue_type_script_setup_true_lang_default from "./RsToolbar.impl.js";
+
+//#region src/components/toolbar/src/RsToolbar.vue
+var RsToolbar_default = RsToolbar_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { RsToolbar_default as default };

package/dist/components/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { default as RsTooltip } from './src/RsTooltip.js';
+export { default as RsTooltipProvider } from './src/RsTooltipProvider.js';

package/dist/components/tooltip/src/RsTooltip.impl.js

@@ -0,0 +1,91 @@
+import { useRsI18n } from "../../../composables/useRsI18n.js";
+import RsIcon_default from "../../icon/src/RsIcon.js";
+import { TooltipContent, TooltipPortal, TooltipRoot, TooltipTrigger } from "../../_shared/src/reka.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, normalizeClass, openBlock, renderSlot, toDisplayString, unref, useSlots, withCtx } from "vue";
+//#region src/components/tooltip/src/RsTooltip.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 0,
+	class: "rs-tooltip__with-icon"
+};
+var _hoisted_2 = {
+	key: 0,
+	class: "rs-tooltip__label"
+};
+var _hoisted_3 = ["aria-label"];
+var RsTooltip_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "RsTooltip",
+	props: {
+		content: {},
+		side: { default: "top" },
+		align: { default: "center" },
+		sideOffset: { default: 6 },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		ignoreNonKeyboardFocus: {
+			type: Boolean,
+			default: true
+		},
+		nowrap: {
+			type: Boolean,
+			default: false
+		},
+		icon: {
+			type: Boolean,
+			default: false
+		},
+		iconName: { default: "info" },
+		ariaLabel: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const slots = useSlots();
+		const { t } = useRsI18n();
+		const hasLabelSlot = computed(() => Boolean(slots.default));
+		const iconAriaLabel = computed(() => props.ariaLabel?.trim() || props.content?.trim() || t("tooltip.help", "Help"));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(TooltipRoot), {
+				disabled: __props.disabled,
+				"ignore-non-keyboard-focus": __props.ignoreNonKeyboardFocus
+			}, {
+				default: withCtx(() => [__props.icon ? (openBlock(), createElementBlock("span", _hoisted_1, [hasLabelSlot.value ? (openBlock(), createElementBlock("span", _hoisted_2, [renderSlot(_ctx.$slots, "default")])) : createCommentVNode("", true), createVNode(unref(TooltipTrigger), { "as-child": "" }, {
+					default: withCtx(() => [createElementVNode("button", {
+						type: "button",
+						class: "rs-tooltip__icon-trigger",
+						"aria-label": iconAriaLabel.value
+					}, [createVNode(RsIcon_default, {
+						name: __props.iconName,
+						size: 12
+					}, null, 8, ["name"])], 8, _hoisted_3)]),
+					_: 1
+				})])) : (openBlock(), createBlock(unref(TooltipTrigger), {
+					key: 1,
+					"as-child": ""
+				}, {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+					_: 3
+				})), createVNode(unref(TooltipPortal), null, {
+					default: withCtx(() => [createVNode(unref(TooltipContent), {
+						class: normalizeClass(["rs-tooltip__content", { "rs-tooltip__content--nowrap": __props.nowrap }]),
+						side: __props.side,
+						align: __props.align,
+						"side-offset": __props.sideOffset
+					}, {
+						default: withCtx(() => [renderSlot(_ctx.$slots, "content", {}, () => [createTextVNode(toDisplayString(__props.content), 1)])]),
+						_: 3
+					}, 8, [
+						"class",
+						"side",
+						"align",
+						"side-offset"
+					])]),
+					_: 3
+				})]),
+				_: 3
+			}, 8, ["disabled", "ignore-non-keyboard-focus"]);
+		};
+	}
+});
+//#endregion
+export { RsTooltip_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/tooltip/src/RsTooltip.js

@@ -0,0 +1,7 @@
+import './RsTooltip.css'
+import RsTooltip_vue_vue_type_script_setup_true_lang_default from "./RsTooltip.impl.js";
+
+//#region src/components/tooltip/src/RsTooltip.vue
+var RsTooltip_default = RsTooltip_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { RsTooltip_default as default };

package/dist/components/tooltip/src/RsTooltipProvider.impl.js

@@ -0,0 +1,32 @@
+import { TooltipProvider } from "../../_shared/src/reka.js";
+import { createBlock, defineComponent, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/tooltip/src/RsTooltipProvider.vue?vue&type=script&setup=true&lang.ts
+var RsTooltipProvider_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "RsTooltipProvider",
+	props: {
+		delayDuration: { default: 300 },
+		skipDelayDuration: { default: 0 },
+		ignoreNonKeyboardFocus: {
+			type: Boolean,
+			default: true
+		}
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(TooltipProvider), {
+				"delay-duration": __props.delayDuration,
+				"skip-delay-duration": __props.skipDelayDuration,
+				"ignore-non-keyboard-focus": __props.ignoreNonKeyboardFocus
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"delay-duration",
+				"skip-delay-duration",
+				"ignore-non-keyboard-focus"
+			]);
+		};
+	}
+});
+//#endregion
+export { RsTooltipProvider_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/tooltip/src/RsTooltipProvider.js

@@ -0,0 +1,5 @@
+import RsTooltipProvider_vue_vue_type_script_setup_true_lang_default from "./RsTooltipProvider.impl.js";
+//#region src/components/tooltip/src/RsTooltipProvider.vue
+var RsTooltipProvider_default = RsTooltipProvider_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { RsTooltipProvider_default as default };

package/dist/components/tree/index.d.ts

@@ -0,0 +1,3 @@
+export { default as RsTree } from './src/RsTree.js';
+export type { RsTreeCheckState, RsTreeDragTrigger, RsTreeDropPosition, RsTreeFieldNames, RsTreeFlatNode, RsTreeFocusMove, RsTreeNode, RsTreeNodeIndex, RsTreeSize, } from './src/tree-utils';
+export { buildTreeNodeIndex, collectDescendantKeys, collectExpandableKeys, collectHalfCheckedKeys, defaultTreeFilterNode, filterTreeNodes, flattenTreeNodeIds, flattenVisibleTreeNodes, getTreeChildren, getTreeKey, getTreeLabel, hasTreeChildren, isTreeAncestorKey, resolveAccordionExpandedKeys, resolveTreeCheckState, resolveTreeFieldNames, resolveTreeFocusKey, resolveTreeIndent, resolveTreeRowHeight, resolveTreeVirtualEnabled, sliceVirtualTreeNodes, splitTreeLabelHighlight, shouldShowTreeCheckbox, toggleTreeCheck, } from './src/tree-utils';