useblocks 1.1.85-dev.9 → 1.1.102

package/vendor/@rc-component/notification/_/@rc-component/util/es/index.js

@@ -0,0 +1,36 @@
+import useEvent from "./hooks/useEvent.js";
+import "./Dom/canUseDom.js";
+import "./hooks/useLayoutEffect.js";
+import "./hooks/useState.js";
+import "./hooks/useMergedState.js";
+import "./hooks/useControlledState.js";
+import wrapperRaf from "./raf.js";
+import "./hooks/useDelayState.js";
+import "./hooks/useId.js";
+import "./hooks/useMemo.js";
+import "./hooks/useSyncState.js";
+import { useComposeRef } from "./ref.js";
+import "./Dom/contains.js";
+import "./Dom/dynamicCSS.js";
+import "./Dom/findDOMNode.js";
+import "./Dom/isVisible.js";
+import "./Dom/focus.js";
+import "./Dom/shadow.js";
+import "./Dom/styleChecker.js";
+import "./KeyCode.js";
+import "./getScrollBarSize.js";
+import "./warning.js";
+import "./isEqual.js";
+import { isNonNullable, isReactRenderable } from "./is.js";
+import "./isMobile.js";
+import "./omit.js";
+import pickAttrs from "./pickAttrs.js";
+import "./proxyObject.js";
+import "./Children/toArray.js";
+import "./mergeProps.js";
+import "./utils/get.js";
+import "./utils/set.js";
+import "./React/render.js";
+import "./test/domHook.js";
+import "./Portal.js";
+export { isNonNullable, isReactRenderable, pickAttrs, wrapperRaf as raf, useComposeRef, useEvent };

package/vendor/@rc-component/notification/_/@rc-component/util/es/is.js

@@ -0,0 +1,21 @@
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/is.js
+/**
+* Check if a value is neither `null` nor `undefined`.
+*/
+function isNonNullable(value) {
+	return value !== void 0 && value !== null;
+}
+/**
+* Check whether a value should be treated as renderable content.
+*
+* Returns `false` only for `null`, `undefined`, `false`, and `''`; all other
+* values, including `0` and `true`, are treated as renderable.
+*
+* This is a compatibility-oriented presence check, not a complete React node
+* validator.
+*/
+function isReactRenderable(value) {
+	return isNonNullable(value) && value !== false && value !== "";
+}
+//#endregion
+export { isNonNullable, isReactRenderable };

package/vendor/@rc-component/notification/_/@rc-component/util/es/isEqual.js

@@ -0,0 +1,35 @@
+import warningOnce from "./warning.js";
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/isEqual.js
+/**
+* Deeply compares two object literals.
+* @param obj1 object 1
+* @param obj2 object 2
+* @param shallow shallow compare
+* @returns
+*/
+function isEqual(obj1, obj2, shallow = false) {
+	const refSet = /* @__PURE__ */ new Set();
+	function deepEqual(a, b, level = 1) {
+		const circular = refSet.has(a);
+		warningOnce(!circular, "Warning: There may be circular references");
+		if (circular) return false;
+		if (a === b) return true;
+		if (shallow && level > 1) return false;
+		refSet.add(a);
+		const newLevel = level + 1;
+		if (Array.isArray(a)) {
+			if (!Array.isArray(b) || a.length !== b.length) return false;
+			for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i], newLevel)) return false;
+			return true;
+		}
+		if (a && b && typeof a === "object" && typeof b === "object") {
+			const keys = Object.keys(a);
+			if (keys.length !== Object.keys(b).length) return false;
+			return keys.every((key) => deepEqual(a[key], b[key], newLevel));
+		}
+		return false;
+	}
+	return deepEqual(obj1, obj2);
+}
+//#endregion
+export { isEqual as default };

package/vendor/@rc-component/notification/_/@rc-component/util/es/isMobile.js

@@ -0,0 +1,11 @@
+import { __toESM } from "../../../../../../_virtual/_virtual/_rolldown/runtime.js";
+import { require_is_mobile } from "../../../../../../is-mobile/index.js";
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/isMobile.js
+var import_is_mobile = /* @__PURE__ */ __toESM(require_is_mobile());
+let cached;
+const getIsMobile = () => {
+	if (typeof cached === "undefined") cached = (0, import_is_mobile.default)();
+	return cached;
+};
+//#endregion
+export { getIsMobile as default };

package/vendor/@rc-component/notification/_/@rc-component/util/es/mergeProps.js

@@ -0,0 +1,14 @@
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/mergeProps.js
+/**
+* Merges multiple props objects into one. Unlike `Object.assign()` or `{ ...a, ...b }`, it skips
+* properties whose value is explicitly set to `undefined`.
+*/
+function mergeProps(...items) {
+	const ret = {};
+	for (const item of items) if (item) {
+		for (const key of Object.keys(item)) if (item[key] !== void 0) ret[key] = item[key];
+	}
+	return ret;
+}
+//#endregion
+export { mergeProps as default };

package/vendor/@rc-component/notification/_/@rc-component/util/es/omit.js

@@ -0,0 +1 @@
+//#endregion

package/vendor/@rc-component/notification/_/@rc-component/util/es/pickAttrs.js

@@ -0,0 +1,50 @@
+const propList = `accept acceptCharset accessKey action allowFullScreen allowTransparency
+    alt async autoComplete autoFocus autoPlay capture cellPadding cellSpacing challenge
+    charSet checked classID className colSpan cols content contentEditable contextMenu
+    controls coords crossOrigin data dateTime default defer dir disabled download draggable
+    encType form formAction formEncType formMethod formNoValidate formTarget frameBorder
+    headers height hidden high href hrefLang htmlFor httpEquiv icon id inputMode integrity
+    is keyParams keyType kind label lang list loop low manifest marginHeight marginWidth max maxLength media
+    mediaGroup method min minLength multiple muted name noValidate nonce open
+    optimum pattern placeholder poster preload radioGroup readOnly rel required
+    reversed role rowSpan rows sandbox scope scoped scrolling seamless selected
+    shape size sizes span spellCheck src srcDoc srcLang srcSet start step style
+    summary tabIndex target title type useMap value width wmode wrap onCopy onCut onPaste onCompositionEnd onCompositionStart onCompositionUpdate onKeyDown
+    onKeyPress onKeyUp onFocus onBlur onChange onInput onSubmit onClick onContextMenu onDoubleClick
+    onDrag onDragEnd onDragEnter onDragExit onDragLeave onDragOver onDragStart onDrop onMouseDown
+    onMouseEnter onMouseLeave onMouseMove onMouseOut onMouseOver onMouseUp onSelect onTouchCancel
+    onTouchEnd onTouchMove onTouchStart onScroll onWheel onAbort onCanPlay onCanPlayThrough
+    onDurationChange onEmptied onEncrypted onEnded onError onLoadedData onLoadedMetadata
+    onLoadStart onPause onPlay onPlaying onProgress onRateChange onSeeked onSeeking onStalled onSuspend onTimeUpdate onVolumeChange onWaiting onLoad
+    onPointerDown onPointerMove onPointerUp onPointerCancel onPointerEnter onPointerLeave onPointerOver onPointerOut onGotPointerCapture onLostPointerCapture
+    onAnimationStart onAnimationEnd onAnimationIteration
+    onTransitionEnd onTransitionRun onTransitionStart onTransitionCancel
+    onBeforeInput onReset onInvalid
+    onAuxClick onToggle onBeforeToggle onCancel onClose onResize onScrollEnd`.split(/[\s\n]+/);
+const ariaPrefix = "aria-";
+const dataPrefix = "data-";
+function match(key, prefix) {
+	return key.indexOf(prefix) === 0;
+}
+/**
+* Picker props from exist props with filter
+* @param props Passed props
+* @param ariaOnly boolean | { aria?: boolean; data?: boolean; attr?: boolean; } filter config
+*/
+function pickAttrs(props, ariaOnly = false) {
+	let mergedConfig;
+	if (ariaOnly === false) mergedConfig = {
+		aria: true,
+		data: true,
+		attr: true
+	};
+	else if (ariaOnly === true) mergedConfig = { aria: true };
+	else mergedConfig = { ...ariaOnly };
+	const attrs = {};
+	Object.keys(props).forEach((key) => {
+		if (mergedConfig.aria && (key === "role" || match(key, ariaPrefix)) || mergedConfig.data && match(key, dataPrefix) || mergedConfig.attr && propList.includes(key)) attrs[key] = props[key];
+	});
+	return attrs;
+}
+//#endregion
+export { pickAttrs as default };

package/vendor/@rc-component/notification/_/@rc-component/util/es/proxyObject.js

@@ -0,0 +1 @@
+//#endregion

package/vendor/@rc-component/notification/_/@rc-component/util/es/raf.js

@@ -0,0 +1,36 @@
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/raf.js
+let raf = (callback) => +setTimeout(callback, 16);
+let caf = (num) => clearTimeout(num);
+if (typeof window !== "undefined" && "requestAnimationFrame" in window) {
+	raf = (callback) => window.requestAnimationFrame(callback);
+	caf = (handle) => window.cancelAnimationFrame(handle);
+}
+let rafUUID = 0;
+const rafIds = /* @__PURE__ */ new Map();
+function cleanup(id) {
+	rafIds.delete(id);
+}
+const wrapperRaf = (callback, times = 1) => {
+	rafUUID += 1;
+	const id = rafUUID;
+	function callRef(leftTimes) {
+		if (leftTimes === 0) {
+			cleanup(id);
+			callback();
+		} else {
+			const realId = raf(() => {
+				callRef(leftTimes - 1);
+			});
+			rafIds.set(id, realId);
+		}
+	}
+	callRef(times);
+	return id;
+};
+wrapperRaf.cancel = (id) => {
+	const realId = rafIds.get(id);
+	cleanup(id);
+	return caf(realId);
+};
+//#endregion
+export { wrapperRaf as default };

package/vendor/@rc-component/notification/_/@rc-component/util/es/ref.js

@@ -0,0 +1,38 @@
+import useMemo$1 from "./hooks/useMemo.js";
+import isFragment from "./React/isFragment.js";
+import { isValidElement, version } from "../../../../../../react/index.js";
+import { ForwardRef, isMemo } from "../../../../../../react-is/index.js";
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/ref.js
+const ReactMajorVersion = Number(version.split(".")[0]);
+const fillRef = (ref, node) => {
+	if (typeof ref === "function") ref(node);
+	else if (typeof ref === "object" && ref && "current" in ref) ref.current = node;
+};
+/**
+* Merge refs into one ref function to support ref passing.
+*/
+const composeRef = (...refs) => {
+	const refList = refs.filter(Boolean);
+	if (refList.length <= 1) return refList[0];
+	return (node) => {
+		refs.forEach((ref) => {
+			fillRef(ref, node);
+		});
+	};
+};
+const useComposeRef = (...refs) => {
+	return useMemo$1(() => composeRef(...refs), refs, (prev, next) => prev.length !== next.length || prev.every((ref, i) => ref !== next[i]));
+};
+const supportRef = (nodeOrComponent) => {
+	if (!nodeOrComponent) return false;
+	if (isReactElement(nodeOrComponent) && ReactMajorVersion >= 19) return true;
+	const type = isMemo(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;
+	if (typeof type === "function" && !type.prototype?.render && type.$$typeof !== ForwardRef) return false;
+	if (typeof nodeOrComponent === "function" && !nodeOrComponent.prototype?.render && nodeOrComponent.$$typeof !== ForwardRef) return false;
+	return true;
+};
+function isReactElement(node) {
+	return /*#__PURE__*/ isValidElement(node) && !isFragment(node);
+}
+//#endregion
+export { composeRef, fillRef, supportRef, useComposeRef };

package/vendor/@rc-component/notification/_/@rc-component/util/es/test/domHook.js

@@ -0,0 +1,36 @@
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/test/domHook.js
+const NO_EXIST = { __NOT_EXIST: true };
+function spyElementPrototypes(elementClass, properties) {
+	const propNames = Object.keys(properties);
+	const originDescriptors = {};
+	propNames.forEach((propName) => {
+		const originDescriptor = Object.getOwnPropertyDescriptor(elementClass.prototype, propName);
+		originDescriptors[propName] = originDescriptor || NO_EXIST;
+		const spyProp = properties[propName];
+		if (typeof spyProp === "function") elementClass.prototype[propName] = function spyFunc(...args) {
+			return spyProp.call(this, originDescriptor, ...args);
+		};
+		else Object.defineProperty(elementClass.prototype, propName, {
+			...spyProp,
+			set(value) {
+				if (spyProp.set) return spyProp.set.call(this, originDescriptor, value);
+				return originDescriptor.set(value);
+			},
+			get() {
+				if (spyProp.get) return spyProp.get.call(this, originDescriptor);
+				return originDescriptor.get();
+			},
+			configurable: true
+		});
+	});
+	return { mockRestore() {
+		propNames.forEach((propName) => {
+			const originDescriptor = originDescriptors[propName];
+			if (originDescriptor === NO_EXIST) delete elementClass.prototype[propName];
+			else if (typeof originDescriptor === "function") elementClass.prototype[propName] = originDescriptor;
+			else Object.defineProperty(elementClass.prototype, propName, originDescriptor);
+		});
+	} };
+}
+//#endregion
+export { spyElementPrototypes };

package/vendor/@rc-component/notification/_/@rc-component/util/es/utils/get.js

@@ -0,0 +1,11 @@
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/utils/get.js
+function get(entity, path) {
+	let current = entity;
+	for (let i = 0; i < path.length; i += 1) {
+		if (current === null || current === void 0) return;
+		current = current[path[i]];
+	}
+	return current;
+}
+//#endregion
+export { get as default };

package/vendor/@rc-component/notification/_/@rc-component/util/es/utils/set.js

@@ -0,0 +1,58 @@
+import get from "./get.js";
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/utils/set.js
+function internalSet(entity, paths, value, removeIfUndefined) {
+	if (!paths.length) return value;
+	const [path, ...restPath] = paths;
+	let clone;
+	if (!entity && typeof path === "number") clone = [];
+	else if (Array.isArray(entity)) clone = [...entity];
+	else clone = { ...entity };
+	if (removeIfUndefined && value === void 0 && restPath.length === 1) delete clone[path][restPath[0]];
+	else clone[path] = internalSet(clone[path], restPath, value, removeIfUndefined);
+	return clone;
+}
+function set(entity, paths, value, removeIfUndefined = false) {
+	if (paths.length && removeIfUndefined && value === void 0 && !get(entity, paths.slice(0, -1))) return entity;
+	return internalSet(entity, paths, value, removeIfUndefined);
+}
+function isObject(obj) {
+	return typeof obj === "object" && obj !== null && Object.getPrototypeOf(obj) === Object.prototype;
+}
+function createEmpty(source) {
+	return Array.isArray(source) ? [] : {};
+}
+const keys = typeof Reflect === "undefined" ? Object.keys : Reflect.ownKeys;
+/**
+* Merge multiple objects. Support custom merge logic.
+* @param sources object sources
+* @param config.prepareArray Customize array prepare function.
+* It will return empty [] by default.
+* So when match array, it will auto be override with next array in sources.
+*/
+function mergeWith(sources, config = {}) {
+	const { prepareArray } = config;
+	const finalPrepareArray = prepareArray || (() => []);
+	let clone = createEmpty(sources[0]);
+	sources.forEach((src) => {
+		function internalMerge(path, parentLoopSet) {
+			const loopSet = new Set(parentLoopSet);
+			const value = get(src, path);
+			const isArr = Array.isArray(value);
+			if (isArr || isObject(value)) {
+				if (!loopSet.has(value)) {
+					loopSet.add(value);
+					const originValue = get(clone, path);
+					if (isArr) clone = set(clone, path, finalPrepareArray(originValue, value));
+					else if (!originValue || typeof originValue !== "object") clone = set(clone, path, createEmpty(value));
+					keys(value).forEach((key) => {
+						if (Object.getOwnPropertyDescriptor(value, key).enumerable) internalMerge([...path, key], loopSet);
+					});
+				}
+			} else clone = set(clone, path, value);
+		}
+		internalMerge([]);
+	});
+	return clone;
+}
+//#endregion
+export { set as default, mergeWith };

package/vendor/@rc-component/notification/_/@rc-component/util/es/warning.js

@@ -0,0 +1,46 @@
+//#region node_modules/@rc-component/notification/node_modules/@rc-component/util/es/warning.js
+let warned = {};
+const preWarningFns = [];
+/**
+* Pre warning enable you to parse content before console.error.
+* Modify to null will prevent warning.
+*/
+const preMessage = (fn) => {
+	preWarningFns.push(fn);
+};
+/**
+* Warning if condition not match.
+* @param valid Condition
+* @param message Warning message
+* @example
+* ```js
+* warning(false, 'some error'); // print some error
+* warning(true, 'some error'); // print nothing
+* warning(1 === 2, 'some error'); // print some error
+* ```
+*/
+function warning(valid, message) {}
+/** @see Similar to {@link warning} */
+function note(valid, message) {}
+function resetWarned() {
+	warned = {};
+}
+function call(method, valid, message) {
+	if (!valid && !warned[message]) {
+		method(false, message);
+		warned[message] = true;
+	}
+}
+/** @see Same as {@link warning}, but only warn once for the same message */
+function warningOnce(valid, message) {
+	call(warning, valid, message);
+}
+/** @see Same as {@link warning}, but only warn once for the same message */
+function noteOnce(valid, message) {
+	call(note, valid, message);
+}
+warningOnce.preMessage = preMessage;
+warningOnce.resetWarned = resetWarned;
+warningOnce.noteOnce = noteOnce;
+//#endregion
+export { call, warningOnce as default, warningOnce, note, noteOnce, preMessage, resetWarned, warning };

package/vendor/@rc-component/notification/_/@rc-component/util/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@rc-component/util",
+  "version": "1.13.0",
+  "license": "MIT",
+  "type": "module"
+}

package/vendor/@rc-component/notification/es/Notification.js

@@ -0,0 +1,129 @@
+import { clsx } from "../../../clsx/dist/clsx.js";
+import useEvent from "../_/@rc-component/util/es/hooks/useEvent.js";
+import { isNonNullable, isReactRenderable } from "../_/@rc-component/util/es/is.js";
+import "../_/@rc-component/util/es/index.js";
+import useNoticeTimer from "./hooks/useNoticeTimer.js";
+import useClosable from "./hooks/useClosable.js";
+import Progress from "./Progress.js";
+import * as React$1 from "../../../react/index.js";
+//#region node_modules/@rc-component/notification/es/Notification.js
+function _extends() {
+	_extends = Object.assign ? Object.assign.bind() : function(target) {
+		for (var i = 1; i < arguments.length; i++) {
+			var source = arguments[i];
+			for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+		}
+		return target;
+	};
+	return _extends.apply(this, arguments);
+}
+const Notification = /*#__PURE__*/ React$1.forwardRef((props, ref) => {
+	const { prefixCls, className, style, classNames, styles, components, title, description, icon, actions, role, closable, offset, notificationIndex, stackInThreshold, props: rootProps, duration = 4.5, showProgress, hovering: forcedHovering, pauseOnHover = true, onClick, onMouseEnter, onMouseLeave, onClose } = props;
+	const [percent, setPercent] = React$1.useState(0);
+	const noticePrefixCls = `${prefixCls}-notice`;
+	const [mergedClosable, closableConfig, closeBtnAriaProps] = useClosable(closable);
+	const onInternalClose = useEvent(() => {
+		closableConfig.onClose?.();
+		onClose?.();
+	});
+	const [hovering, setHovering] = React$1.useState(false);
+	const [onResume, onPause] = useNoticeTimer(duration, onInternalClose, setPercent);
+	const validPercent = 100 - Math.min(Math.max(percent * 100, 0), 100);
+	const Progress$1 = components?.progress || Progress;
+	React$1.useEffect(() => {
+		if (!pauseOnHover) return;
+		if (forcedHovering) onPause();
+		else if (!hovering) onResume();
+	}, [
+		forcedHovering,
+		hovering,
+		onPause,
+		onResume,
+		pauseOnHover
+	]);
+	function onInternalMouseEnter(event) {
+		setHovering(true);
+		if (pauseOnHover) onPause();
+		onMouseEnter?.(event);
+	}
+	function onInternalMouseLeave(event) {
+		setHovering(false);
+		if (pauseOnHover && !forcedHovering) onResume();
+		onMouseLeave?.(event);
+	}
+	function onInternalCloseClick(event) {
+		event.preventDefault();
+		event.stopPropagation();
+		onInternalClose();
+	}
+	const destroy = useEvent(() => {
+		if (hovering) onInternalMouseLeave();
+	});
+	React$1.useEffect(() => destroy, [destroy]);
+	const offsetRef = React$1.useRef(offset);
+	if (offset !== void 0) offsetRef.current = offset;
+	const notificationIndexRef = React$1.useRef(notificationIndex);
+	if (notificationIndex !== void 0) notificationIndexRef.current = notificationIndex;
+	const mergedOffset = offset ?? offsetRef.current;
+	const mergedNotificationIndex = notificationIndex ?? notificationIndexRef.current ?? 0;
+	const titleNode = isNonNullable(title) ? /*#__PURE__*/ React$1.createElement("div", {
+		className: clsx(`${noticePrefixCls}-title`, classNames?.title),
+		style: styles?.title
+	}, title) : null;
+	const descNode = isNonNullable(description) ? /*#__PURE__*/ React$1.createElement("div", {
+		className: clsx(`${noticePrefixCls}-description`, classNames?.description),
+		style: styles?.description
+	}, description) : null;
+	const hasTitle = titleNode !== null;
+	const hasDescription = descNode !== null;
+	let contentNode;
+	if (hasTitle && hasDescription) contentNode = /*#__PURE__*/ React$1.createElement("div", {
+		className: clsx(`${noticePrefixCls}-section`, classNames?.section),
+		style: styles?.section
+	}, titleNode, descNode);
+	else contentNode = titleNode || descNode;
+	if (isNonNullable(icon)) contentNode = /*#__PURE__*/ React$1.createElement("div", {
+		className: clsx(`${noticePrefixCls}-wrapper`, classNames?.wrapper),
+		style: styles?.wrapper
+	}, /*#__PURE__*/ React$1.createElement("div", {
+		className: clsx(`${noticePrefixCls}-icon`, classNames?.icon),
+		style: styles?.icon
+	}, icon), contentNode);
+	const actionsNode = isReactRenderable(actions) ? /*#__PURE__*/ React$1.createElement("div", {
+		className: clsx(`${noticePrefixCls}-actions`, classNames?.actions),
+		style: styles?.actions
+	}, actions) : null;
+	const mergedStyle = {
+		"--notification-index": mergedNotificationIndex,
+		...styles?.root,
+		...style
+	};
+	if (mergedOffset !== void 0) mergedStyle["--notification-y"] = `${mergedOffset}px`;
+	const mergedRole = role ?? rootProps?.role ?? "alert";
+	return /*#__PURE__*/ React$1.createElement("div", _extends({}, rootProps, {
+		ref,
+		role: mergedRole,
+		"data-notification-index": mergedNotificationIndex,
+		className: clsx(noticePrefixCls, className, classNames?.root, {
+			[`${noticePrefixCls}-closable`]: mergedClosable,
+			[`${noticePrefixCls}-stack-in-threshold`]: stackInThreshold
+		}),
+		style: mergedStyle,
+		onClick,
+		onMouseEnter: onInternalMouseEnter,
+		onMouseLeave: onInternalMouseLeave
+	}), contentNode, actionsNode, mergedClosable && /*#__PURE__*/ React$1.createElement("button", _extends({
+		type: "button",
+		className: clsx(`${noticePrefixCls}-close`, classNames?.close),
+		"aria-label": "Close"
+	}, closeBtnAriaProps, {
+		style: styles?.close,
+		onClick: onInternalCloseClick
+	}), closableConfig.closeIcon), showProgress && typeof duration === "number" && duration > 0 && /*#__PURE__*/ React$1.createElement(Progress$1, {
+		className: clsx(`${noticePrefixCls}-progress`, classNames?.progress),
+		percent: validPercent,
+		style: styles?.progress
+	}));
+});
+//#endregion
+export { Notification as default };

package/vendor/@rc-component/notification/es/NotificationList/Content.js

@@ -0,0 +1,33 @@
+import { clsx } from "../../../../clsx/dist/clsx.js";
+import * as React$1 from "../../../../react/index.js";
+//#region node_modules/@rc-component/notification/es/NotificationList/Content.js
+function _extends() {
+	_extends = Object.assign ? Object.assign.bind() : function(target) {
+		for (var i = 1; i < arguments.length; i++) {
+			var source = arguments[i];
+			for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+		}
+		return target;
+	};
+	return _extends.apply(this, arguments);
+}
+const Content = /*#__PURE__*/ React$1.forwardRef((props, ref) => {
+	const { listPrefixCls, height, topNoticeHeight = 0, topNoticeWidth = 0, className, style, ...restProps } = props;
+	const contentPrefixCls = `${listPrefixCls}-content`;
+	const prevHeightRef = React$1.useRef(height);
+	const heightStatus = height < prevHeightRef.current ? "decrease" : "increase";
+	prevHeightRef.current = height;
+	const contentStyle = {
+		...style,
+		height,
+		"--top-notificiation-height": `${topNoticeHeight}px`,
+		"--top-notificiation-width": `${topNoticeWidth}px`
+	};
+	return /*#__PURE__*/ React$1.createElement("div", _extends({}, restProps, {
+		className: clsx(contentPrefixCls, `${contentPrefixCls}-${heightStatus}`, className),
+		style: contentStyle,
+		ref
+	}));
+});
+//#endregion
+export { Content as default };