niuma-ui 2.0.3 → 2.0.9

package/dist/components/loading-bar/src/RsLoadingBar.d.ts

@@ -1,25 +1,69 @@
+import { type RsLoadingBarAttach, type RsLoadingBarPosition, type RsLoadingBarTone } from './loading-bar-utils';
 type __VLS_Props = {
-    /** 受控进度 0-100；未传时由 start/finish/error 驱动 */
+    /** 受控进度 0–100。传入后显隐只跟这个值，命令式 API 不再改这条。 */
     progress?: number;
+    /** 条高（px）。默认 2，与 --rs-loading-bar-size 一致；未改默认时不写内联，方便覆盖 token。 */
     height?: number;
+    /** 进度色。未传走 tone / --rs-loading-bar-color。 */
     color?: string;
+    /** 失败色。未传走 --rs-loading-bar-error。 */
     errorColor?: string;
+    /** 色相。color 传入时以 color 为准。 */
+    tone?: RsLoadingBarTone;
+    /** 贴上沿或下沿。 */
+    position?: RsLoadingBarPosition;
+    /** viewport 固定在窗口；parent 绝对定位到最近的定位祖先。 */
+    attach?: RsLoadingBarAttach;
+    /** 是否自动向 maximum 蠕动。 */
+    trickle?: boolean;
+    /** trickle 间隔（ms）。小于 16 回落 200。 */
+    trickleSpeed?: number;
+    /** start 的起步进度。 */
+    minimum?: number;
+    /** trickle 停住的上限，finish 才会到 100。 */
+    maximum?: number;
+    /** 短请求不闪条。delay 内 finish 则从不显示。0 与历史行为一致。 */
+    delay?: number;
+    /** finish 后淡出毫秒。 */
+    finishDuration?: number;
+    /** error 后淡出毫秒。 */
+    errorDuration?: number;
+    /** 重叠的 start/finish 计数。默认关闭，每次 start 仍会回到 minimum。 */
+    nesting?: boolean;
+    /** 未知进度：滑动条，不报 aria-valuenow。 */
+    indeterminate?: boolean;
+    /** 覆盖可访问名称。未传走 loadingBar.label / loadingBar.error。 */
+    ariaLabel?: string;
+    id?: string;
 };
-declare function start(): void;
-declare function finish(): void;
-declare function error(): void;
 declare var __VLS_1: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    start: typeof start;
-    finish: typeof finish;
-    error: typeof error;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    color: string;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, import("./loading-bar-utils").RsLoadingBarExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (progress: number) => any;
+    error: () => any;
+    start: (pending: number) => any;
+    finish: (pending: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((progress: number) => any) | undefined;
+    onError?: (() => any) | undefined;
+    onStart?: ((pending: number) => any) | undefined;
+    onFinish?: ((pending: number) => any) | undefined;
+}>, {
     height: number;
-    errorColor: string;
+    tone: RsLoadingBarTone;
+    indeterminate: boolean;
+    position: RsLoadingBarPosition;
+    attach: RsLoadingBarAttach;
+    trickle: boolean;
+    trickleSpeed: number;
+    minimum: number;
+    maximum: number;
+    delay: number;
+    finishDuration: number;
+    errorDuration: number;
+    nesting: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/loading-bar/src/RsLoadingBar.impl.js

@@ -1,109 +1,350 @@
+import { useRsI18n } from "../../../composables/useRsI18n.js";
 import { RS_LOADING_BAR_KEY } from "../../../composables/useRsLoadingBar.js";
+import { advanceLoadingBar, clampLoadingBar, loadingBarHasTimerHost, nextLoadingBarInc, resolveLoadingBarAttach, resolveLoadingBarDelay, resolveLoadingBarDuration, resolveLoadingBarHeight, resolveLoadingBarPosition, resolveLoadingBarRange, resolveLoadingBarSpeed, resolveLoadingBarTone } from "./loading-bar-utils.js";
 import { Fragment, computed, createElementBlock, createElementVNode, defineComponent, normalizeClass, normalizeStyle, onBeforeUnmount, openBlock, provide, ref, renderSlot, shallowRef, watch } from "vue";
 //#region src/components/loading-bar/src/RsLoadingBar.vue?vue&type=script&setup=true&lang.ts
 var _hoisted_1 = [
+	"id",
 	"role",
 	"aria-hidden",
-	"aria-valuenow",
+	"aria-label",
 	"aria-valuemin",
-	"aria-valuemax"
+	"aria-valuemax",
+	"aria-valuenow",
+	"aria-valuetext"
 ];
 var RsLoadingBar_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RsLoadingBar",
 	__name: "RsLoadingBar",
 	props: {
 		progress: {},
 		height: { default: 2 },
-		color: { default: "var(--rs-primary)" },
-		errorColor: { default: "var(--rs-danger)" }
+		color: {},
+		errorColor: {},
+		tone: { default: "primary" },
+		position: { default: "top" },
+		attach: { default: "viewport" },
+		trickle: {
+			type: Boolean,
+			default: true
+		},
+		trickleSpeed: { default: 200 },
+		minimum: { default: 8 },
+		maximum: { default: 92 },
+		delay: { default: 0 },
+		finishDuration: { default: 280 },
+		errorDuration: { default: 400 },
+		nesting: {
+			type: Boolean,
+			default: false
+		},
+		indeterminate: {
+			type: Boolean,
+			default: false
+		},
+		ariaLabel: {},
+		id: {}
 	},
-	setup(__props, { expose: __expose }) {
+	emits: [
+		"start",
+		"finish",
+		"error",
+		"change"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
 		const props = __props;
+		const emit = __emit;
+		const { t } = useRsI18n();
 		const internalProgress = ref(0);
 		const visible = ref(false);
 		const errored = ref(false);
+		let pending = 0;
+		let waiting = false;
+		let lastPublished = -1;
 		let trickleTimer = null;
-		const displayProgress = computed(() => props.progress !== void 0 ? Math.min(100, Math.max(0, props.progress)) : internalProgress.value);
-		const isVisible = computed(() => visible.value || props.progress !== void 0 && props.progress > 0);
-		const barStyle = computed(() => ({
-			height: `${props.height}px`,
-			width: `${displayProgress.value}%`,
-			background: errored.value ? props.errorColor : props.color
-		}));
+		let hideTimer = null;
+		let delayTimer = null;
+		const tone = computed(() => resolveLoadingBarTone(props.tone));
+		const position = computed(() => resolveLoadingBarPosition(props.position));
+		const attach = computed(() => resolveLoadingBarAttach(props.attach));
+		const controlled = computed(() => props.progress !== void 0);
+		const indeterminateActive = computed(() => props.indeterminate && !controlled.value && !errored.value);
+		const displayProgress = computed(() => controlled.value ? clampLoadingBar(props.progress ?? 0) : internalProgress.value);
+		const label = computed(() => {
+			if (props.ariaLabel) return props.ariaLabel;
+			if (errored.value) return t("loadingBar.error");
+			if (indeterminateActive.value) return t("loadingBar.indeterminate");
+			return t("loadingBar.label");
+		});
+		const valueNow = computed(() => {
+			if (!visible.value || indeterminateActive.value) return void 0;
+			return Math.round(displayProgress.value);
+		});
+		const valueText = computed(() => {
+			if (!visible.value) return void 0;
+			if (errored.value) return t("loadingBar.error");
+			if (indeterminateActive.value) return t("loadingBar.indeterminate");
+		});
+		const rootStyle = computed(() => {
+			const style = {};
+			const height = resolveLoadingBarHeight(props.height);
+			if (height !== 2) style["--rs-loading-bar-size"] = `${height}px`;
+			if (props.color) style["--rs-loading-bar-color"] = props.color;
+			if (props.errorColor) style["--rs-loading-bar-error"] = props.errorColor;
+			if (!indeterminateActive.value) style["--rs-loading-bar-progress"] = `${displayProgress.value}%`;
+			return style;
+		});
+		function timerHost() {
+			if (typeof window === "undefined") return null;
+			return loadingBarHasTimerHost(window) ? window : null;
+		}
+		function publish(value) {
+			if (controlled.value || props.indeterminate) return;
+			const rounded = Math.round(value);
+			if (rounded === lastPublished) return;
+			lastPublished = rounded;
+			emit("change", rounded);
+		}
 		function clearTrickle() {
-			if (trickleTimer) {
-				clearInterval(trickleTimer);
-				trickleTimer = null;
-			}
+			const host = timerHost();
+			if (trickleTimer !== null && host) host.clearInterval(trickleTimer);
+			trickleTimer = null;
 		}
-		function start() {
+		function clearHide() {
+			const host = timerHost();
+			if (hideTimer !== null && host) host.clearTimeout(hideTimer);
+			hideTimer = null;
+		}
+		function clearDelay() {
+			const host = timerHost();
+			if (delayTimer !== null && host) host.clearTimeout(delayTimer);
+			delayTimer = null;
+			waiting = false;
+		}
+		function clearTimers() {
 			clearTrickle();
+			clearHide();
+			clearDelay();
+		}
+		function armHide(ms, done) {
+			clearHide();
+			const host = timerHost();
+			if (!host) {
+				done();
+				return;
+			}
+			hideTimer = host.setTimeout(() => {
+				hideTimer = null;
+				done();
+			}, ms);
+		}
+		function hideLater(ms) {
+			armHide(ms, () => {
+				visible.value = false;
+				errored.value = false;
+				internalProgress.value = 0;
+				lastPublished = -1;
+			});
+		}
+		function ensureTrickle() {
+			if (controlled.value || !props.trickle || props.indeterminate) {
+				clearTrickle();
+				return;
+			}
+			const { maximum } = resolveLoadingBarRange(props.minimum, props.maximum);
+			if (internalProgress.value >= maximum) {
+				clearTrickle();
+				return;
+			}
+			if (trickleTimer) return;
+			const host = timerHost();
+			if (!host) return;
+			trickleTimer = host.setInterval(() => {
+				const cap = resolveLoadingBarRange(props.minimum, props.maximum).maximum;
+				if (internalProgress.value >= cap) {
+					clearTrickle();
+					return;
+				}
+				const next = advanceLoadingBar(internalProgress.value, cap);
+				internalProgress.value = next;
+				publish(next);
+				if (next >= cap) clearTrickle();
+			}, resolveLoadingBarSpeed(props.trickleSpeed));
+		}
+		function reveal(value) {
 			errored.value = false;
 			visible.value = true;
-			internalProgress.value = 8;
-			trickleTimer = setInterval(() => {
-				if (internalProgress.value >= 92) return;
-				const step = Math.max(.5, (92 - internalProgress.value) * .08);
-				internalProgress.value = Math.min(92, internalProgress.value + step);
-			}, 200);
+			if (props.indeterminate) {
+				clearTrickle();
+				return;
+			}
+			internalProgress.value = value;
+			publish(value);
+			ensureTrickle();
 		}
-		function finish() {
+		function complete(erroredNext) {
+			pending = 0;
+			waiting = false;
 			clearTrickle();
-			errored.value = false;
+			clearDelay();
+			errored.value = erroredNext;
 			visible.value = true;
-			internalProgress.value = 100;
-			window.setTimeout(() => {
-				visible.value = false;
-				internalProgress.value = 0;
-			}, 280);
+			if (!props.indeterminate || erroredNext) {
+				internalProgress.value = 100;
+				if (!props.indeterminate) publish(100);
+			}
+			hideLater(resolveLoadingBarDuration(erroredNext ? props.errorDuration : props.finishDuration, erroredNext ? 400 : 280));
 		}
-		function error() {
+		function start() {
+			if (controlled.value) return;
+			clearHide();
+			errored.value = false;
+			if (props.nesting && pending > 0) {
+				pending += 1;
+				emit("start", pending);
+				return;
+			}
+			pending = 1;
 			clearTrickle();
-			errored.value = true;
-			visible.value = true;
-			internalProgress.value = 100;
-			window.setTimeout(() => {
+			clearDelay();
+			const delay = resolveLoadingBarDelay(props.delay);
+			const minimum = resolveLoadingBarRange(props.minimum, props.maximum).minimum;
+			if (delay > 0) {
+				const host = timerHost();
+				if (!host) {
+					reveal(minimum);
+					emit("start", pending);
+					return;
+				}
+				waiting = true;
+				delayTimer = host.setTimeout(() => {
+					delayTimer = null;
+					waiting = false;
+					if (pending <= 0) return;
+					reveal(minimum);
+				}, delay);
+				emit("start", pending);
+				return;
+			}
+			reveal(minimum);
+			emit("start", pending);
+		}
+		function finish() {
+			if (controlled.value) return;
+			if (props.nesting && pending > 1) {
+				pending -= 1;
+				emit("finish", pending);
+				return;
+			}
+			if (waiting) {
+				clearDelay();
+				pending = 0;
+				emit("finish", 0);
+				return;
+			}
+			complete(false);
+			emit("finish", 0);
+		}
+		function error() {
+			if (controlled.value) return;
+			complete(true);
+			emit("error");
+		}
+		function set(progress) {
+			if (controlled.value || props.indeterminate) return;
+			const next = clampLoadingBar(progress);
+			clearHide();
+			clearDelay();
+			errored.value = false;
+			if (next >= 100) {
+				complete(false);
+				emit("finish", 0);
+				return;
+			}
+			if (next <= 0) {
+				pending = 0;
+				clearTrickle();
 				visible.value = false;
-				errored.value = false;
 				internalProgress.value = 0;
-			}, 400);
+				publish(0);
+				return;
+			}
+			if (pending === 0) pending = 1;
+			visible.value = true;
+			internalProgress.value = next;
+			publish(next);
+			ensureTrickle();
+		}
+		function inc(amount) {
+			if (controlled.value || props.indeterminate) return;
+			if (pending <= 0 && !visible.value) {
+				start();
+				return;
+			}
+			set(nextLoadingBarInc(internalProgress.value, amount));
+		}
+		function getProgress() {
+			return Math.round(displayProgress.value);
+		}
+		function isStarted() {
+			return pending > 0;
 		}
 		const api = shallowRef({
 			start,
 			finish,
-			error
+			error,
+			set,
+			inc,
+			getProgress,
+			isStarted
 		});
 		provide(RS_LOADING_BAR_KEY, api);
 		watch(() => props.progress, (value) => {
 			if (value === void 0) return;
-			visible.value = value > 0 && value < 100;
-			if (value >= 100) {
-				visible.value = true;
-				window.setTimeout(() => {
-					visible.value = false;
-				}, 280);
+			clearHide();
+			clearTrickle();
+			const next = clampLoadingBar(value);
+			if (next <= 0) {
+				visible.value = false;
+				return;
 			}
-		});
+			visible.value = true;
+			if (next >= 100) hideLater(resolveLoadingBarDuration(props.finishDuration, 280));
+		}, { immediate: true });
 		onBeforeUnmount(() => {
-			clearTrickle();
+			clearTimers();
+			pending = 0;
 			api.value = null;
 		});
 		__expose({
 			start,
 			finish,
-			error
+			error,
+			set,
+			inc,
+			getProgress,
+			isStarted
 		});
 		return (_ctx, _cache) => {
 			return openBlock(), createElementBlock(Fragment, null, [createElementVNode("div", {
-				class: normalizeClass(["rs-loading-bar", { "rs-loading-bar--visible": isVisible.value }]),
-				role: isVisible.value ? "progressbar" : void 0,
-				"aria-hidden": isVisible.value ? void 0 : "true",
-				"aria-valuenow": isVisible.value ? Math.round(displayProgress.value) : void 0,
-				"aria-valuemin": isVisible.value ? 0 : void 0,
-				"aria-valuemax": isVisible.value ? 100 : void 0
-			}, [createElementVNode("div", {
-				class: "rs-loading-bar__peg",
-				style: normalizeStyle(barStyle.value)
-			}, null, 4)], 10, _hoisted_1), renderSlot(_ctx.$slots, "default", {}, void 0, true)], 64);
+				id: __props.id || void 0,
+				class: normalizeClass(["rs-loading-bar", {
+					"rs-loading-bar--visible": visible.value,
+					"rs-loading-bar--bottom": position.value === "bottom",
+					"rs-loading-bar--parent": attach.value === "parent",
+					"rs-loading-bar--error": errored.value,
+					"rs-loading-bar--indeterminate": indeterminateActive.value,
+					[`rs-loading-bar--${tone.value}`]: true
+				}]),
+				style: normalizeStyle(rootStyle.value),
+				role: visible.value ? "progressbar" : void 0,
+				"aria-hidden": visible.value ? void 0 : "true",
+				"aria-label": visible.value ? label.value : void 0,
+				"aria-valuemin": valueNow.value !== void 0 ? 0 : void 0,
+				"aria-valuemax": valueNow.value !== void 0 ? 100 : void 0,
+				"aria-valuenow": valueNow.value,
+				"aria-valuetext": valueText.value
+			}, [..._cache[0] || (_cache[0] = [createElementVNode("div", { class: "rs-loading-bar__peg" }, null, -1)])], 14, _hoisted_1), renderSlot(_ctx.$slots, "default", {}, void 0, true)], 64);
 		};
 	}
 });

package/dist/components/loading-bar/src/RsLoadingBar.js

@@ -3,6 +3,6 @@ import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_exp
 import RsLoadingBar_vue_vue_type_script_setup_true_lang_default from "./RsLoadingBar.impl.js";
 
 //#region src/components/loading-bar/src/RsLoadingBar.vue
-var RsLoadingBar_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsLoadingBar_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-98c35618"]]);
+var RsLoadingBar_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsLoadingBar_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-aff2ed50"]]);
 //#endregion
 export { RsLoadingBar_default as default };

package/dist/components/loading-bar/src/loading-bar-utils.d.ts

@@ -0,0 +1,69 @@
+/** 色相。未传走 primary，对应 --rs-loading-bar-color。 */
+export type RsLoadingBarTone = 'primary' | 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+/** 贴视口上沿或下沿。 */
+export type RsLoadingBarPosition = 'top' | 'bottom';
+/** viewport 相对窗口 fixed；parent 相对最近定位祖先 absolute。 */
+export type RsLoadingBarAttach = 'viewport' | 'parent';
+/** 命令式 API。useRsLoadingBar 与组件 ref 同一套方法。 */
+export interface RsLoadingBarExpose {
+    /** 开始。默认把进度拉到 minimum 并 trickle。nesting 时重复调用只加计数。 */
+    start: () => void;
+    /** 结束。默认补到 100 后淡出。nesting 时计数归零才淡出。 */
+    finish: () => void;
+    /** 失败。清计数，用错误色补到 100 后淡出。 */
+    error: () => void;
+    /** 把未受控进度设到 0–100。100 等同结束，0 立刻隐藏。 */
+    set: (progress: number) => void;
+    /** 在当前进度上增加。未开始时等同 start，不会加到 100。 */
+    inc: (amount?: number) => void;
+    /** 当前展示进度（四舍五入）。未开始为 0。 */
+    getProgress: () => number;
+    /** 是否仍有未结束的 start（含 delay 等待、nesting 计数）。淡出过程中为 false。 */
+    isStarted: () => boolean;
+}
+export type RsLoadingBarApi = RsLoadingBarExpose;
+export type RsLoadingBarInstance = RsLoadingBarExpose & {
+    $el: HTMLElement;
+};
+export declare const RS_LOADING_BAR_TONES: readonly ["primary", "neutral", "info", "success", "warning", "danger"];
+export declare const RS_LOADING_BAR_POSITIONS: readonly ["top", "bottom"];
+export declare const RS_LOADING_BAR_ATTACHES: readonly ["viewport", "parent"];
+export declare const RS_LOADING_BAR_DEFAULT_HEIGHT = 2;
+export declare const RS_LOADING_BAR_DEFAULT_MINIMUM = 8;
+export declare const RS_LOADING_BAR_DEFAULT_MAXIMUM = 92;
+export declare const RS_LOADING_BAR_DEFAULT_SPEED = 200;
+export declare const RS_LOADING_BAR_DEFAULT_FINISH_MS = 280;
+export declare const RS_LOADING_BAR_DEFAULT_ERROR_MS = 400;
+/** inc 停在 100 以下，避免没调用 finish 就当成完成。 */
+export declare const RS_LOADING_BAR_INC_CAP = 99.4;
+export declare function clampLoadingBar(value: number): number;
+export declare function isRsLoadingBarTone(value: unknown): value is RsLoadingBarTone;
+export declare function isRsLoadingBarPosition(value: unknown): value is RsLoadingBarPosition;
+export declare function isRsLoadingBarAttach(value: unknown): value is RsLoadingBarAttach;
+export declare function resolveLoadingBarTone(tone?: string | null): RsLoadingBarTone;
+export declare function resolveLoadingBarPosition(position?: string | null): RsLoadingBarPosition;
+export declare function resolveLoadingBarAttach(attach?: string | null): RsLoadingBarAttach;
+/** 非正数或非法回落 2，与历史默认高度一致。 */
+export declare function resolveLoadingBarHeight(height?: number | null): number;
+/**
+ * trickle 上限与起步值。minimum 大于 maximum 时把起步压到上限，避免一启动就停住。
+ */
+export declare function resolveLoadingBarRange(minimum?: number | null, maximum?: number | null): {
+    minimum: number;
+    maximum: number;
+};
+/** 低于 16ms 视为误传，回落 200，避免 0 间隔打满主线程。 */
+export declare function resolveLoadingBarSpeed(speed?: number | null): number;
+export declare function resolveLoadingBarDelay(delay?: number | null): number;
+export declare function resolveLoadingBarDuration(duration: number | null | undefined, fallback: number): number;
+/**
+ * 与历史 trickle 相同：步长为剩余距离的 8%，至少 0.5，不超过 ceiling。
+ */
+export declare function advanceLoadingBar(current: number, ceiling: number): number;
+/**
+ * 未知增量时越接近完成步长越小（NProgress 的 0–1 标度换成 0–100）。
+ * 结果不超过 INC_CAP，把「到 100」留给 finish / error / set。
+ */
+export declare function nextLoadingBarInc(current: number, amount?: number): number;
+/** SSR / 无 window 时不排定时器。 */
+export declare function loadingBarHasTimerHost(host: unknown): host is Pick<Window, 'setTimeout' | 'setInterval' | 'clearTimeout' | 'clearInterval'>;

package/dist/components/loading-bar/src/loading-bar-utils.js

@@ -0,0 +1,97 @@
+//#region src/components/loading-bar/src/loading-bar-utils.ts
+var RS_LOADING_BAR_TONES = [
+	"primary",
+	"neutral",
+	"info",
+	"success",
+	"warning",
+	"danger"
+];
+var RS_LOADING_BAR_POSITIONS = ["top", "bottom"];
+var RS_LOADING_BAR_ATTACHES = ["viewport", "parent"];
+/** inc 停在 100 以下，避免没调用 finish 就当成完成。 */
+var RS_LOADING_BAR_INC_CAP = 99.4;
+function clampLoadingBar(value) {
+	if (!Number.isFinite(value)) return 0;
+	return Math.min(100, Math.max(0, value));
+}
+function isRsLoadingBarTone(value) {
+	return typeof value === "string" && RS_LOADING_BAR_TONES.includes(value);
+}
+function isRsLoadingBarPosition(value) {
+	return typeof value === "string" && RS_LOADING_BAR_POSITIONS.includes(value);
+}
+function isRsLoadingBarAttach(value) {
+	return typeof value === "string" && RS_LOADING_BAR_ATTACHES.includes(value);
+}
+function resolveLoadingBarTone(tone) {
+	return isRsLoadingBarTone(tone) ? tone : "primary";
+}
+function resolveLoadingBarPosition(position) {
+	return isRsLoadingBarPosition(position) ? position : "top";
+}
+function resolveLoadingBarAttach(attach) {
+	return isRsLoadingBarAttach(attach) ? attach : "viewport";
+}
+/** 非正数或非法回落 2，与历史默认高度一致。 */
+function resolveLoadingBarHeight(height) {
+	if (typeof height !== "number" || !Number.isFinite(height) || height <= 0) return 2;
+	return height;
+}
+/**
+* trickle 上限与起步值。minimum 大于 maximum 时把起步压到上限，避免一启动就停住。
+*/
+function resolveLoadingBarRange(minimum, maximum) {
+	const min = typeof minimum === "number" && Number.isFinite(minimum) ? clampLoadingBar(minimum) : 8;
+	const max = typeof maximum === "number" && Number.isFinite(maximum) ? clampLoadingBar(maximum) : 92;
+	return {
+		minimum: Math.min(min, max),
+		maximum: max
+	};
+}
+/** 低于 16ms 视为误传，回落 200，避免 0 间隔打满主线程。 */
+function resolveLoadingBarSpeed(speed) {
+	if (typeof speed !== "number" || !Number.isFinite(speed) || speed < 16) return 200;
+	return speed;
+}
+function resolveLoadingBarDelay(delay) {
+	if (typeof delay !== "number" || !Number.isFinite(delay) || delay < 0) return 0;
+	return delay;
+}
+function resolveLoadingBarDuration(duration, fallback) {
+	if (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0) return fallback;
+	return duration;
+}
+/**
+* 与历史 trickle 相同：步长为剩余距离的 8%，至少 0.5，不超过 ceiling。
+*/
+function advanceLoadingBar(current, ceiling) {
+	const value = clampLoadingBar(current);
+	const cap = clampLoadingBar(ceiling);
+	if (value >= cap) return value;
+	const step = Math.max(.5, (cap - value) * .08);
+	return Math.min(cap, value + step);
+}
+/**
+* 未知增量时越接近完成步长越小（NProgress 的 0–1 标度换成 0–100）。
+* 结果不超过 INC_CAP，把「到 100」留给 finish / error / set。
+*/
+function nextLoadingBarInc(current, amount) {
+	const value = clampLoadingBar(current);
+	if (value >= 100) return 100;
+	let step = amount;
+	if (typeof step !== "number" || !Number.isFinite(step)) if (value < 20) step = 10;
+	else if (value < 50) step = 4;
+	else if (value < 80) step = 2;
+	else if (value < 99) step = .5;
+	else step = 0;
+	return Math.min(RS_LOADING_BAR_INC_CAP, Math.max(0, value + step));
+}
+/** SSR / 无 window 时不排定时器。 */
+function loadingBarHasTimerHost(host) {
+	if (!host || typeof host !== "object") return false;
+	const candidate = host;
+	return typeof candidate.setTimeout === "function" && typeof candidate.setInterval === "function" && typeof candidate.clearTimeout === "function" && typeof candidate.clearInterval === "function";
+}
+//#endregion
+export { RS_LOADING_BAR_ATTACHES, RS_LOADING_BAR_INC_CAP, RS_LOADING_BAR_POSITIONS, RS_LOADING_BAR_TONES, advanceLoadingBar, clampLoadingBar, isRsLoadingBarAttach, isRsLoadingBarPosition, isRsLoadingBarTone, loadingBarHasTimerHost, nextLoadingBarInc, resolveLoadingBarAttach, resolveLoadingBarDelay, resolveLoadingBarDuration, resolveLoadingBarHeight, resolveLoadingBarPosition, resolveLoadingBarRange, resolveLoadingBarSpeed, resolveLoadingBarTone };