@lumx/vue 4.17.1-alpha.2 → 4.17.1-alpha.3

package/_internal/node_modules/lodash/memoize.js

@@ -0,0 +1,69 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__MapCache } from "./_MapCache.js";
+//#region ../../node_modules/lodash/memoize.js
+var require_memoize = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var MapCache = require__MapCache();
+	/** Error message constants. */
+	var FUNC_ERROR_TEXT = "Expected a function";
+	/**
+	* Creates a function that memoizes the result of `func`. If `resolver` is
+	* provided, it determines the cache key for storing the result based on the
+	* arguments provided to the memoized function. By default, the first argument
+	* provided to the memoized function is used as the map cache key. The `func`
+	* is invoked with the `this` binding of the memoized function.
+	*
+	* **Note:** The cache is exposed as the `cache` property on the memoized
+	* function. Its creation may be customized by replacing the `_.memoize.Cache`
+	* constructor with one whose instances implement the
+	* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+	* method interface of `clear`, `delete`, `get`, `has`, and `set`.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Function
+	* @param {Function} func The function to have its output memoized.
+	* @param {Function} [resolver] The function to resolve the cache key.
+	* @returns {Function} Returns the new memoized function.
+	* @example
+	*
+	* var object = { 'a': 1, 'b': 2 };
+	* var other = { 'c': 3, 'd': 4 };
+	*
+	* var values = _.memoize(_.values);
+	* values(object);
+	* // => [1, 2]
+	*
+	* values(other);
+	* // => [3, 4]
+	*
+	* object.a = 2;
+	* values(object);
+	* // => [1, 2]
+	*
+	* // Modify the result cache.
+	* values.cache.set(object, ['a', 'b']);
+	* values(object);
+	* // => ['a', 'b']
+	*
+	* // Replace `_.memoize.Cache`.
+	* _.memoize.Cache = WeakMap;
+	*/
+	function memoize(func, resolver) {
+		if (typeof func != "function" || resolver != null && typeof resolver != "function") throw new TypeError(FUNC_ERROR_TEXT);
+		var memoized = function() {
+			var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+			if (cache.has(key)) return cache.get(key);
+			var result = func.apply(this, args);
+			memoized.cache = cache.set(key, result) || cache;
+			return result;
+		};
+		memoized.cache = new (memoize.Cache || MapCache)();
+		return memoized;
+	}
+	memoize.Cache = MapCache;
+	module.exports = memoize;
+}));
+//#endregion
+export default require_memoize();
+export { require_memoize };

package/_internal/node_modules/lodash/pick.js

@@ -0,0 +1,13 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__basePick } from "./_basePick.js";
+import { require__flatRest } from "./_flatRest.js";
+//#region ../../node_modules/lodash/pick.js
+var require_pick = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var basePick = require__basePick();
+	module.exports = require__flatRest()(function(object, paths) {
+		return object == null ? {} : basePick(object, paths);
+	});
+}));
+//#endregion
+export default require_pick();
+export { require_pick };

package/_internal/node_modules/lodash/pull.js

@@ -0,0 +1,10 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__baseRest } from "./_baseRest.js";
+import { require_pullAll } from "./pullAll.js";
+//#region ../../node_modules/lodash/pull.js
+var require_pull = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require__baseRest()(require_pullAll());
+}));
+//#endregion
+export default require_pull();
+export { require_pull };

package/_internal/node_modules/lodash/pullAll.js

@@ -0,0 +1,33 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__basePullAll } from "./_basePullAll.js";
+//#region ../../node_modules/lodash/pullAll.js
+var require_pullAll = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var basePullAll = require__basePullAll();
+	/**
+	* This method is like `_.pull` except that it accepts an array of values to remove.
+	*
+	* **Note:** Unlike `_.difference`, this method mutates `array`.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Array
+	* @param {Array} array The array to modify.
+	* @param {Array} values The values to remove.
+	* @returns {Array} Returns `array`.
+	* @example
+	*
+	* var array = ['a', 'b', 'c', 'a', 'b', 'c'];
+	*
+	* _.pullAll(array, ['a', 'c']);
+	* console.log(array);
+	* // => ['b', 'b']
+	*/
+	function pullAll(array, values) {
+		return array && array.length && values && values.length ? basePullAll(array, values) : array;
+	}
+	module.exports = pullAll;
+}));
+//#endregion
+export default require_pullAll();
+export { require_pullAll };

package/_internal/node_modules/lodash/set.js

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__baseSet } from "./_baseSet.js";
+//#region ../../node_modules/lodash/set.js
+var require_set = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseSet = require__baseSet();
+	/**
+	* Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
+	* it's created. Arrays are created for missing index properties while objects
+	* are created for all other missing properties. Use `_.setWith` to customize
+	* `path` creation.
+	*
+	* **Note:** This method mutates `object`.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.7.0
+	* @category Object
+	* @param {Object} object The object to modify.
+	* @param {Array|string} path The path of the property to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns `object`.
+	* @example
+	*
+	* var object = { 'a': [{ 'b': { 'c': 3 } }] };
+	*
+	* _.set(object, 'a[0].b.c', 4);
+	* console.log(object.a[0].b.c);
+	* // => 4
+	*
+	* _.set(object, ['x', '0', 'y', 'z'], 5);
+	* console.log(object.x[0].y.z);
+	* // => 5
+	*/
+	function set(object, path, value) {
+		return object == null ? object : baseSet(object, path, value);
+	}
+	module.exports = set;
+}));
+//#endregion
+export default require_set();
+export { require_set };

package/_internal/node_modules/lodash/stubFalse.js

@@ -0,0 +1,24 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/lodash/stubFalse.js
+var require_stubFalse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* This method returns `false`.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.13.0
+	* @category Util
+	* @returns {boolean} Returns `false`.
+	* @example
+	*
+	* _.times(2, _.stubFalse);
+	* // => [false, false]
+	*/
+	function stubFalse() {
+		return false;
+	}
+	module.exports = stubFalse;
+}));
+//#endregion
+export default require_stubFalse();
+export { require_stubFalse };

package/_internal/node_modules/lodash/take.js

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require_toInteger } from "./toInteger.js";
+import { require__baseSlice } from "./_baseSlice.js";
+//#region ../../node_modules/lodash/take.js
+var require_take = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseSlice = require__baseSlice(), toInteger = require_toInteger();
+	/**
+	* Creates a slice of `array` with `n` elements taken from the beginning.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Array
+	* @param {Array} array The array to query.
+	* @param {number} [n=1] The number of elements to take.
+	* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+	* @returns {Array} Returns the slice of `array`.
+	* @example
+	*
+	* _.take([1, 2, 3]);
+	* // => [1]
+	*
+	* _.take([1, 2, 3], 2);
+	* // => [1, 2]
+	*
+	* _.take([1, 2, 3], 5);
+	* // => [1, 2, 3]
+	*
+	* _.take([1, 2, 3], 0);
+	* // => []
+	*/
+	function take(array, n, guard) {
+		if (!(array && array.length)) return [];
+		n = guard || n === void 0 ? 1 : toInteger(n);
+		return baseSlice(array, 0, n < 0 ? 0 : n);
+	}
+	module.exports = take;
+}));
+//#endregion
+export default require_take();
+export { require_take };

package/_internal/node_modules/lodash/toFinite.js

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require_toNumber } from "./toNumber.js";
+//#region ../../node_modules/lodash/toFinite.js
+var require_toFinite = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var toNumber = require_toNumber();
+	/** Used as references for various `Number` constants. */
+	var INFINITY = Infinity, MAX_INTEGER = 17976931348623157e292;
+	/**
+	* Converts `value` to a finite number.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.12.0
+	* @category Lang
+	* @param {*} value The value to convert.
+	* @returns {number} Returns the converted number.
+	* @example
+	*
+	* _.toFinite(3.2);
+	* // => 3.2
+	*
+	* _.toFinite(Number.MIN_VALUE);
+	* // => 5e-324
+	*
+	* _.toFinite(Infinity);
+	* // => 1.7976931348623157e+308
+	*
+	* _.toFinite('3.2');
+	* // => 3.2
+	*/
+	function toFinite(value) {
+		if (!value) return value === 0 ? value : 0;
+		value = toNumber(value);
+		if (value === INFINITY || value === -INFINITY) return (value < 0 ? -1 : 1) * MAX_INTEGER;
+		return value === value ? value : 0;
+	}
+	module.exports = toFinite;
+}));
+//#endregion
+export default require_toFinite();
+export { require_toFinite };

package/_internal/node_modules/lodash/toInteger.js

@@ -0,0 +1,40 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require_toFinite } from "./toFinite.js";
+//#region ../../node_modules/lodash/toInteger.js
+var require_toInteger = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var toFinite = require_toFinite();
+	/**
+	* Converts `value` to an integer.
+	*
+	* **Note:** This method is loosely based on
+	* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to convert.
+	* @returns {number} Returns the converted integer.
+	* @example
+	*
+	* _.toInteger(3.2);
+	* // => 3
+	*
+	* _.toInteger(Number.MIN_VALUE);
+	* // => 0
+	*
+	* _.toInteger(Infinity);
+	* // => 1.7976931348623157e+308
+	*
+	* _.toInteger('3.2');
+	* // => 3
+	*/
+	function toInteger(value) {
+		var result = toFinite(value), remainder = result % 1;
+		return result === result ? remainder ? result - remainder : result : 0;
+	}
+	module.exports = toInteger;
+}));
+//#endregion
+export default require_toInteger();
+export { require_toInteger };

package/_internal/node_modules/lodash/toNumber.js

@@ -0,0 +1,57 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require_isObject } from "./isObject.js";
+import { require_isSymbol } from "./isSymbol.js";
+import { require__baseTrim } from "./_baseTrim.js";
+//#region ../../node_modules/lodash/toNumber.js
+var require_toNumber = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseTrim = require__baseTrim(), isObject = require_isObject(), isSymbol = require_isSymbol();
+	/** Used as references for various `Number` constants. */
+	var NAN = NaN;
+	/** Used to detect bad signed hexadecimal string values. */
+	var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+	/** Used to detect binary string values. */
+	var reIsBinary = /^0b[01]+$/i;
+	/** Used to detect octal string values. */
+	var reIsOctal = /^0o[0-7]+$/i;
+	/** Built-in method references without a dependency on `root`. */
+	var freeParseInt = parseInt;
+	/**
+	* Converts `value` to a number.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to process.
+	* @returns {number} Returns the number.
+	* @example
+	*
+	* _.toNumber(3.2);
+	* // => 3.2
+	*
+	* _.toNumber(Number.MIN_VALUE);
+	* // => 5e-324
+	*
+	* _.toNumber(Infinity);
+	* // => Infinity
+	*
+	* _.toNumber('3.2');
+	* // => 3.2
+	*/
+	function toNumber(value) {
+		if (typeof value == "number") return value;
+		if (isSymbol(value)) return NAN;
+		if (isObject(value)) {
+			var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+			value = isObject(other) ? other + "" : other;
+		}
+		if (typeof value != "string") return value === 0 ? value : +value;
+		value = baseTrim(value);
+		var isBinary = reIsBinary.test(value);
+		return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+	}
+	module.exports = toNumber;
+}));
+//#endregion
+export default require_toNumber();
+export { require_toNumber };

package/_internal/node_modules/lodash/toString.js

@@ -0,0 +1,34 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__baseToString } from "./_baseToString.js";
+//#region ../../node_modules/lodash/toString.js
+var require_toString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseToString = require__baseToString();
+	/**
+	* Converts `value` to a string. An empty string is returned for `null`
+	* and `undefined` values. The sign of `-0` is preserved.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to convert.
+	* @returns {string} Returns the converted string.
+	* @example
+	*
+	* _.toString(null);
+	* // => ''
+	*
+	* _.toString(-0);
+	* // => '-0'
+	*
+	* _.toString([1, 2, 3]);
+	* // => '1,2,3'
+	*/
+	function toString(value) {
+		return value == null ? "" : baseToString(value);
+	}
+	module.exports = toString;
+}));
+//#endregion
+export default require_toString();
+export { require_toString };

package/_internal/node_modules/vue/jsx-runtime/index.d.ts

@@ -0,0 +1 @@
+import { Fragment } from "../../@vue/runtime-core/dist/runtime-core.js";

package/_internal/node_modules/vue-demi/lib/index.js

@@ -0,0 +1,34 @@
+import { __exportAll, __reExport } from "../../../_virtual/_rolldown/runtime.js";
+import * as Vue from "vue";
+export * from "vue";
+//#region ../../node_modules/vue-demi/lib/index.mjs
+var lib_exports = /* @__PURE__ */ __exportAll({
+	Vue: () => Vue,
+	Vue2: () => void 0,
+	del: () => del,
+	install: () => install,
+	isVue2: () => false,
+	isVue3: () => true,
+	set: () => set
+});
+import * as import_vue from "vue";
+__reExport(lib_exports, import_vue);
+function install() {}
+function set(target, key, val) {
+	if (Array.isArray(target)) {
+		target.length = Math.max(target.length, key);
+		target.splice(key, 1, val);
+		return val;
+	}
+	target[key] = val;
+	return val;
+}
+function del(target, key) {
+	if (Array.isArray(target)) {
+		target.splice(key, 1);
+		return;
+	}
+	delete target[key];
+}
+//#endregion
+export { lib_exports };

package/_internal/packages/lumx-core/src/js/components/AlertDialog/index.d.ts

@@ -0,0 +1,15 @@
+import { Kind } from "../../constants/enums/index.js";
+import { JSXElement } from "../../types/JSXElement.js";
+//#region ../lumx-core/src/js/components/AlertDialog/index.d.ts
+interface BaseAlertDialogProps {
+  /** Message variant. */
+  kind?: Kind;
+  /** Dialog title. */
+  title?: string;
+  /**
+   * Children
+   */
+  children?: JSXElement;
+}
+//#endregion
+export { BaseAlertDialogProps };

package/_internal/packages/lumx-core/src/js/components/AlertDialog/index.js

@@ -0,0 +1,107 @@
+import { ColorPalette, Emphasis, Kind, Size } from "../../constants/enums/index.js";
+import { bem } from "../../utils/classNames/bem/index.js";
+import { import_classnames } from "../../utils/classNames/index.js";
+import { Fragment, createVNode, isVNode, mergeProps } from "vue";
+import { mdiAlert } from "@lumx/icons/esm/alert.js";
+import { mdiAlertCircle } from "@lumx/icons/esm/alert-circle.js";
+import { mdiCheckCircle } from "@lumx/icons/esm/check-circle.js";
+import { mdiInformation } from "@lumx/icons/esm/information.js";
+//#region ../lumx-core/src/js/components/AlertDialog/index.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+/**
+* Associative map from message kind to color and icon.
+*/
+var CONFIG = {
+	[Kind.error]: {
+		color: ColorPalette.red,
+		icon: mdiAlert
+	},
+	[Kind.info]: {
+		color: ColorPalette.blue,
+		icon: mdiInformation
+	},
+	[Kind.success]: {
+		color: ColorPalette.green,
+		icon: mdiCheckCircle
+	},
+	[Kind.warning]: {
+		color: ColorPalette.yellow,
+		icon: mdiAlertCircle
+	}
+};
+/**
+* Component display name.
+*/
+var COMPONENT_NAME = "AlertDialog";
+var { block } = bem("lumx-alert-dialog");
+/**
+* Component default props.
+*/
+var DEFAULT_PROPS = {
+	size: Size.tiny,
+	kind: Kind.info
+};
+/**
+* AlertDialog component.
+*
+* An alert dialog is a modal dialog that interrupts the user's workflow to
+* communicate an important message and acquire a response.
+*
+* It should not have a complex content.
+* Children of this component should only be strings, paragraphs or links.
+*/
+var AlertDialog = (props) => {
+	const { id, title, className, cancelProps, confirmProps, ref, kind = DEFAULT_PROPS.kind, size = DEFAULT_PROPS.size, dialogProps, children, DescriptionElement, cancelButtonRef, confirmationButtonRef, focusElement, Dialog, Toolbar, Button, Icon, ...forwardedProps } = props;
+	const { color, icon } = CONFIG[kind] || {};
+	const titleId = `${id}-title`;
+	const descriptionId = `${id}-description`;
+	const { label: confirmLabel, onClick: confirmOnClick, ...forwardedConfirmProps } = confirmProps;
+	const { label: cancelLabel, onClick: cancelOnClick, ...forwardedCancelProps } = cancelProps || {};
+	return createVNode(Dialog, mergeProps({
+		"ref": ref,
+		"focusElement": focusElement ?? (cancelProps ? cancelButtonRef : confirmationButtonRef),
+		"size": size,
+		"dialogProps": {
+			id,
+			role: "alertdialog",
+			"aria-labelledby": titleId,
+			"aria-describedby": descriptionId,
+			...dialogProps
+		},
+		"className": import_classnames.default(className, block({ [`kind-${kind}`]: Boolean(kind) }))
+	}, forwardedProps), { default: () => [
+		createVNode("header", null, [createVNode(Toolbar, {
+			"className": "lumx-spacing-margin-horizontal",
+			"before": createVNode(Icon, {
+				"icon": icon,
+				"size": Size.s,
+				"color": color
+			}, null),
+			"label": createVNode("h2", {
+				"id": titleId,
+				"className": "lumx-typography-title"
+			}, [title])
+		}, null)]),
+		children && createVNode(DescriptionElement, {
+			"id": descriptionId,
+			"className": "lumx-typography-body2 lumx-spacing-padding-vertical-big lumx-spacing-padding-horizontal-huge"
+		}, _isSlot(children) ? children : { default: () => [children] }),
+		createVNode("footer", null, [createVNode(Toolbar, {
+			"className": "lumx-spacing-margin-horizontal",
+			"after": createVNode(Fragment, null, [cancelProps && createVNode(Button, mergeProps(forwardedCancelProps, {
+				"ref": cancelButtonRef,
+				"emphasis": Emphasis.medium,
+				"onClick": cancelOnClick
+			}), _isSlot(cancelLabel) ? cancelLabel : { default: () => [cancelLabel] }), createVNode(Button, mergeProps(forwardedConfirmProps, {
+				"ref": confirmationButtonRef,
+				"color": color,
+				"className": "lumx-spacing-margin-left-regular",
+				"onClick": confirmOnClick
+			}), _isSlot(confirmLabel) ? confirmLabel : { default: () => [confirmLabel] })])
+		}, null)])
+	] });
+};
+//#endregion
+export { AlertDialog, COMPONENT_NAME };

package/_internal/packages/lumx-core/src/js/components/Avatar/index.d.ts

@@ -0,0 +1,27 @@
+import { Size } from "../../constants/enums/index.js";
+import { HasClassName } from "../../types/HasClassName.js";
+import { HasTheme } from "../../types/HasTheme.js";
+import { JSXElement } from "../../types/JSXElement.js";
+import { CommonRef } from "../../types/CommonRef.js";
+//#region ../lumx-core/src/js/components/Avatar/index.d.ts
+/**
+ * Avatar sizes.
+ */
+type AvatarSize = Extract<Size, 'xxs' | 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl'>;
+/**
+ * Defines the props of the component.
+ */
+interface AvatarProps extends HasTheme, HasClassName {
+  /** Action toolbar content. */
+  actions?: JSXElement;
+  /** Badge. */
+  badge?: JSXElement;
+  /** Image URL. */
+  image: JSXElement;
+  /** Size variant. */
+  size?: AvatarSize;
+  /** Props to pass to the thumbnail (minus those already set by the Avatar props). */
+  ref?: CommonRef;
+}
+//#endregion
+export { AvatarProps, AvatarSize };

package/_internal/packages/lumx-core/src/js/components/Avatar/index.js

@@ -0,0 +1,29 @@
+import { Size } from "../../constants/enums/index.js";
+import { bem } from "../../utils/classNames/bem/index.js";
+import { import_classnames } from "../../utils/classNames/index.js";
+import { createVNode, mergeProps } from "vue";
+var { block, element } = bem("lumx-avatar");
+/**
+* Component default props.
+*/
+var DEFAULT_PROPS = { size: Size.m };
+/**
+* Avatar component.
+*
+* @param  props Component props.
+* @param  ref   Component ref.
+* @return React element.
+*/
+var Avatar = (props) => {
+	const { actions, badge, className, image, size = DEFAULT_PROPS.size, theme, ref, ...forwardedProps } = props;
+	return createVNode("div", mergeProps({ "ref": ref }, forwardedProps, { "className": import_classnames.default(className, block({
+		[`size-${size}`]: Boolean(size),
+		[`theme-${theme}`]: Boolean(theme)
+	})) }), [
+		image,
+		actions && createVNode("div", { "className": element("actions") }, [actions]),
+		badge && createVNode("div", { "className": element("badge") }, [badge])
+	]);
+};
+//#endregion
+export { Avatar, DEFAULT_PROPS, element };

package/_internal/packages/lumx-core/src/js/components/Badge/BadgeWrapper.d.ts

@@ -0,0 +1,14 @@
+import { HasClassName } from "../../types/HasClassName.js";
+import { JSXElement } from "../../types/JSXElement.js";
+import { CommonRef } from "../../types/CommonRef.js";
+//#region ../lumx-core/src/js/components/Badge/BadgeWrapper.d.ts
+interface BadgeWrapperProps extends HasClassName {
+  /** Badge element to display */
+  badge?: JSXElement;
+  /** Content to wrap with badge */
+  children?: JSXElement;
+  /** Ref forwarding */
+  ref?: CommonRef;
+}
+//#endregion
+export { BadgeWrapperProps };

package/_internal/packages/lumx-core/src/js/components/Badge/BadgeWrapper.js

@@ -0,0 +1,12 @@
+import { bem } from "../../utils/classNames/bem/index.js";
+import { import_classnames } from "../../utils/classNames/index.js";
+import { createVNode, mergeProps } from "vue";
+//#region ../lumx-core/src/js/components/Badge/BadgeWrapper.tsx
+var CLASSNAME = "lumx-badge-wrapper";
+var { block, element } = bem(CLASSNAME);
+var BadgeWrapper = (props) => {
+	const { badge, children, className, ref, ...forwardedProps } = props;
+	return createVNode("div", mergeProps({ "ref": ref }, forwardedProps, { "className": import_classnames.default(className, block()) }), [children, badge && createVNode("div", { "className": element("badge") }, [badge])]);
+};
+//#endregion
+export { BadgeWrapper, CLASSNAME };