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

package/_internal/node_modules/@floating-ui/utils/dist/floating-ui.utils.js

@@ -0,0 +1,135 @@
+//#region ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+/**
+* Custom positioning reference element.
+* @see https://floating-ui.com/docs/virtual-elements
+*/
+var sides = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+var alignments = ["start", "end"];
+var placements = /*#__PURE__*/ sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
+var min = Math.min;
+var max = Math.max;
+var round = Math.round;
+var floor = Math.floor;
+var createCoords = (v) => ({
+	x: v,
+	y: v
+});
+var oppositeSideMap = {
+	left: "right",
+	right: "left",
+	bottom: "top",
+	top: "bottom"
+};
+var oppositeAlignmentMap = {
+	start: "end",
+	end: "start"
+};
+function clamp(start, value, end) {
+	return max(start, min(value, end));
+}
+function evaluate(value, param) {
+	return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+	return placement.split("-")[0];
+}
+function getAlignment(placement) {
+	return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+	return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+	return axis === "y" ? "height" : "width";
+}
+var yAxisSides = /*#__PURE__*/ new Set(["top", "bottom"]);
+function getSideAxis(placement) {
+	return yAxisSides.has(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+	return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+	if (rtl === void 0) rtl = false;
+	const alignment = getAlignment(placement);
+	const alignmentAxis = getAlignmentAxis(placement);
+	const length = getAxisLength(alignmentAxis);
+	let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+	if (rects.reference[length] > rects.floating[length]) mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+	return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+	const oppositePlacement = getOppositePlacement(placement);
+	return [
+		getOppositeAlignmentPlacement(placement),
+		oppositePlacement,
+		getOppositeAlignmentPlacement(oppositePlacement)
+	];
+}
+function getOppositeAlignmentPlacement(placement) {
+	return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+var lrPlacement = ["left", "right"];
+var rlPlacement = ["right", "left"];
+var tbPlacement = ["top", "bottom"];
+var btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+	switch (side) {
+		case "top":
+		case "bottom":
+			if (rtl) return isStart ? rlPlacement : lrPlacement;
+			return isStart ? lrPlacement : rlPlacement;
+		case "left":
+		case "right": return isStart ? tbPlacement : btPlacement;
+		default: return [];
+	}
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+	const alignment = getAlignment(placement);
+	let list = getSideList(getSide(placement), direction === "start", rtl);
+	if (alignment) {
+		list = list.map((side) => side + "-" + alignment);
+		if (flipAlignment) list = list.concat(list.map(getOppositeAlignmentPlacement));
+	}
+	return list;
+}
+function getOppositePlacement(placement) {
+	return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...padding
+	};
+}
+function getPaddingObject(padding) {
+	return typeof padding !== "number" ? expandPaddingObject(padding) : {
+		top: padding,
+		right: padding,
+		bottom: padding,
+		left: padding
+	};
+}
+function rectToClientRect(rect) {
+	const { x, y, width, height } = rect;
+	return {
+		width,
+		height,
+		top: y,
+		left: x,
+		right: x + width,
+		bottom: y + height,
+		x,
+		y
+	};
+}
+//#endregion
+export { clamp, createCoords, evaluate, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round };

package/_internal/node_modules/@floating-ui/vue/dist/floating-ui.vue.js

@@ -0,0 +1,145 @@
+import { getNodeName, isNode } from "../../utils/dist/floating-ui.utils.dom.js";
+import { computePosition } from "../../dom/dist/floating-ui.dom.js";
+import { lib_exports } from "../../../vue-demi/lib/index.js";
+//#region ../../node_modules/@floating-ui/vue/dist/floating-ui.vue.mjs
+function isComponentPublicInstance(target) {
+	return target != null && typeof target === "object" && "$el" in target;
+}
+function unwrapElement(target) {
+	if (isComponentPublicInstance(target)) {
+		const element = target.$el;
+		return isNode(element) && getNodeName(element) === "#comment" ? null : element;
+	}
+	return target;
+}
+function toValue(source) {
+	return typeof source === "function" ? source() : (0, lib_exports.unref)(source);
+}
+function getDPR(element) {
+	if (typeof window === "undefined") return 1;
+	return (element.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function roundByDPR(element, value) {
+	const dpr = getDPR(element);
+	return Math.round(value * dpr) / dpr;
+}
+/**
+* Computes the `x` and `y` coordinates that will place the floating element next to a reference element when it is given a certain CSS positioning strategy.
+* @param reference The reference template ref.
+* @param floating The floating template ref.
+* @param options The floating options.
+* @see https://floating-ui.com/docs/vue
+*/
+function useFloating(reference, floating, options) {
+	if (options === void 0) options = {};
+	const whileElementsMountedOption = options.whileElementsMounted;
+	const openOption = (0, lib_exports.computed)(() => {
+		var _toValue;
+		return (_toValue = toValue(options.open)) != null ? _toValue : true;
+	});
+	const middlewareOption = (0, lib_exports.computed)(() => toValue(options.middleware));
+	const placementOption = (0, lib_exports.computed)(() => {
+		var _toValue2;
+		return (_toValue2 = toValue(options.placement)) != null ? _toValue2 : "bottom";
+	});
+	const strategyOption = (0, lib_exports.computed)(() => {
+		var _toValue3;
+		return (_toValue3 = toValue(options.strategy)) != null ? _toValue3 : "absolute";
+	});
+	const transformOption = (0, lib_exports.computed)(() => {
+		var _toValue4;
+		return (_toValue4 = toValue(options.transform)) != null ? _toValue4 : true;
+	});
+	const referenceElement = (0, lib_exports.computed)(() => unwrapElement(reference.value));
+	const floatingElement = (0, lib_exports.computed)(() => unwrapElement(floating.value));
+	const x = (0, lib_exports.ref)(0);
+	const y = (0, lib_exports.ref)(0);
+	const strategy = (0, lib_exports.ref)(strategyOption.value);
+	const placement = (0, lib_exports.ref)(placementOption.value);
+	const middlewareData = (0, lib_exports.shallowRef)({});
+	const isPositioned = (0, lib_exports.ref)(false);
+	const floatingStyles = (0, lib_exports.computed)(() => {
+		const initialStyles = {
+			position: strategy.value,
+			left: "0",
+			top: "0"
+		};
+		if (!floatingElement.value) return initialStyles;
+		const xVal = roundByDPR(floatingElement.value, x.value);
+		const yVal = roundByDPR(floatingElement.value, y.value);
+		if (transformOption.value) return {
+			...initialStyles,
+			transform: "translate(" + xVal + "px, " + yVal + "px)",
+			...getDPR(floatingElement.value) >= 1.5 && { willChange: "transform" }
+		};
+		return {
+			position: strategy.value,
+			left: xVal + "px",
+			top: yVal + "px"
+		};
+	});
+	let whileElementsMountedCleanup;
+	function update() {
+		if (referenceElement.value == null || floatingElement.value == null) return;
+		const open = openOption.value;
+		computePosition(referenceElement.value, floatingElement.value, {
+			middleware: middlewareOption.value,
+			placement: placementOption.value,
+			strategy: strategyOption.value
+		}).then((position) => {
+			x.value = position.x;
+			y.value = position.y;
+			strategy.value = position.strategy;
+			placement.value = position.placement;
+			middlewareData.value = position.middlewareData;
+			/**
+			* The floating element's position may be recomputed while it's closed
+			* but still mounted (such as when transitioning out). To ensure
+			* `isPositioned` will be `false` initially on the next open, avoid
+			* setting it to `true` when `open === false` (must be specified).
+			*/
+			isPositioned.value = open !== false;
+		});
+	}
+	function cleanup() {
+		if (typeof whileElementsMountedCleanup === "function") {
+			whileElementsMountedCleanup();
+			whileElementsMountedCleanup = void 0;
+		}
+	}
+	function attach() {
+		cleanup();
+		if (whileElementsMountedOption === void 0) {
+			update();
+			return;
+		}
+		if (referenceElement.value != null && floatingElement.value != null) {
+			whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
+			return;
+		}
+	}
+	function reset() {
+		if (!openOption.value) isPositioned.value = false;
+	}
+	(0, lib_exports.watch)([
+		middlewareOption,
+		placementOption,
+		strategyOption,
+		openOption
+	], update, { flush: "sync" });
+	(0, lib_exports.watch)([referenceElement, floatingElement], attach, { flush: "sync" });
+	(0, lib_exports.watch)(openOption, reset, { flush: "sync" });
+	if ((0, lib_exports.getCurrentScope)()) (0, lib_exports.onScopeDispose)(cleanup);
+	return {
+		x: (0, lib_exports.shallowReadonly)(x),
+		y: (0, lib_exports.shallowReadonly)(y),
+		strategy: (0, lib_exports.shallowReadonly)(strategy),
+		placement: (0, lib_exports.shallowReadonly)(placement),
+		middlewareData: (0, lib_exports.shallowReadonly)(middlewareData),
+		isPositioned: (0, lib_exports.shallowReadonly)(isPositioned),
+		floatingStyles,
+		update
+	};
+}
+//#endregion
+export { useFloating };

package/_internal/node_modules/@vue/reactivity/dist/reactivity.d.ts

@@ -0,0 +1,104 @@
+//#region ../../node_modules/@vue/reactivity/dist/reactivity.d.ts
+declare enum TrackOpTypes {
+  GET = "get",
+  HAS = "has",
+  ITERATE = "iterate"
+}
+declare enum TriggerOpTypes {
+  SET = "set",
+  ADD = "add",
+  DELETE = "delete",
+  CLEAR = "clear"
+}
+type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
+declare const ShallowReactiveMarker: unique symbol;
+type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+type Builtin = Primitive | Function | Date | Error | RegExp;
+type EffectScheduler = (...args: any[]) => any;
+type DebuggerEvent = {
+  effect: Subscriber;
+} & DebuggerEventExtraInfo;
+type DebuggerEventExtraInfo = {
+  target: object;
+  type: TrackOpTypes | TriggerOpTypes;
+  key: any;
+  newValue?: any;
+  oldValue?: any;
+  oldTarget?: Map<any, any> | Set<any>;
+};
+interface DebuggerOptions {
+  onTrack?: (event: DebuggerEvent) => void;
+  onTrigger?: (event: DebuggerEvent) => void;
+}
+interface ReactiveEffectOptions extends DebuggerOptions {
+  scheduler?: EffectScheduler;
+  allowRecurse?: boolean;
+  onStop?: () => void;
+}
+/**
+ * Subscriber is a type that tracks (or subscribes to) a list of deps.
+ */
+interface Subscriber extends DebuggerOptions {}
+declare class ReactiveEffect<T = any> implements Subscriber, ReactiveEffectOptions {
+  fn: () => T;
+  scheduler?: EffectScheduler;
+  onStop?: () => void;
+  onTrack?: (event: DebuggerEvent) => void;
+  onTrigger?: (event: DebuggerEvent) => void;
+  constructor(fn: () => T);
+  pause(): void;
+  resume(): void;
+  run(): T;
+  stop(): void;
+  trigger(): void;
+  get dirty(): boolean;
+}
+type ComputedGetter<T> = (oldValue?: T) => T;
+type ComputedSetter<T> = (newValue: T) => void;
+interface WritableComputedOptions<T, S = T> {
+  get: ComputedGetter<T>;
+  set: ComputedSetter<S>;
+}
+declare const RefSymbol: unique symbol;
+declare const RawSymbol: unique symbol;
+interface Ref<T = any, S = T> {
+  get value(): T;
+  set value(_: S);
+  /**
+   * Type differentiator only.
+   * We need this to be in public d.ts but don't want it to show up in IDE
+   * autocomplete, so we use a private Symbol instead.
+   */
+  [RefSymbol]: true;
+}
+declare const ShallowRefMarker: unique symbol;
+type ShallowRef<T = any, S = T> = Ref<T, S> & {
+  [ShallowRefMarker]?: true;
+};
+/**
+ * This is a special exported interface for other packages to declare
+ * additional types that should bail out for ref unwrapping. For example
+ * \@vue/runtime-dom can declare it like so in its d.ts:
+ *
+ * ``` ts
+ * declare module '@vue/reactivity' {
+ *   export interface RefUnwrapBailTypes {
+ *     runtimeDOMBailTypes: Node | Window
+ *   }
+ * }
+ * ```
+ */
+interface RefUnwrapBailTypes {}
+type ShallowUnwrapRef<T> = { [K in keyof T]: DistributeRef<T[K]> };
+type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
+type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
+type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
+  [RawSymbol]?: true;
+} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? { [K in keyof T]: UnwrapRefSimple<T[K]> } : T extends object & {
+  [ShallowReactiveMarker]?: never;
+} ? { [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]> } : T;
+type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
+type OnCleanup = (cleanupFn: () => void) => void;
+type WatchStopHandle = () => void;
+//#endregion
+export { ComputedGetter, ComputedSetter, DebuggerEvent, DebuggerEventExtraInfo, DebuggerOptions, EffectScheduler, OnCleanup, ReactiveEffect, ReactiveEffectOptions, Ref, ShallowRef, ShallowUnwrapRef, TrackOpTypes, TriggerOpTypes, UnwrapNestedRefs, UnwrapRef, WatchCallback, WatchStopHandle, WritableComputedOptions };