@indielayer/ui 1.18.1 → 2.1.0

package/lib/components/popover/Popover.vue.d.ts

@@ -4,11 +4,18 @@ import { type Placement, type TriggerEvent } from 'floating-vue';
 export type PopoverPlacement = Placement;
 export type PopoverTriggerEvent = TriggerEvent;
 declare const popoverProps: {
-    disabled: BooleanConstructor;
-    positioningDisabled: BooleanConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        description: string;
+    };
+    positioningDisabled: {
+        type: BooleanConstructor;
+        description: string;
+    };
     placement: {
         type: PropType<Placement>;
         default: string;
+        description: string;
     };
     delay: {
         type: PropType<string | number | {
@@ -16,55 +23,108 @@ declare const popoverProps: {
             hide: number;
         }>;
         default: number;
+        description: string;
+    };
+    distance: {
+        type: (StringConstructor | NumberConstructor)[];
+        description: string;
+    };
+    skidding: {
+        type: (StringConstructor | NumberConstructor)[];
+        description: string;
     };
-    distance: (StringConstructor | NumberConstructor)[];
-    skidding: (StringConstructor | NumberConstructor)[];
     triggers: {
         type: PropType<TriggerEvent[]>;
         default: () => string[];
+        description: string;
     };
     hideArrow: {
         type: BooleanConstructor;
         default: boolean;
+        description: string;
+    };
+    showTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
+        description: string;
+    };
+    hideTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
+        description: string;
+    };
+    popperTriggers: {
+        type: PropType<TriggerEvent[]>;
+        description: string;
+    };
+    popperShowTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
+        description: string;
+    };
+    popperHideTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
+        description: string;
     };
-    showTriggers: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
-    hideTriggers: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
-    popperTriggers: PropType<TriggerEvent[]>;
-    popperShowTriggers: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
-    popperHideTriggers: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
     container: {
         type: (BooleanConstructor | ObjectConstructor | StringConstructor)[];
         default: string;
+        description: string;
+    };
+    boundary: {
+        type: (ObjectConstructor | StringConstructor)[];
+        description: string;
     };
-    boundary: (ObjectConstructor | StringConstructor)[];
     strategy: {
         type: PropType<"absolute" | "fixed">;
         default: string;
+        description: string;
     };
     autoHide: {
         type: PropType<boolean | ((event: Event) => boolean)>;
         default: boolean;
+        description: string;
+    };
+    shown: {
+        type: BooleanConstructor;
+        description: string;
     };
-    shown: BooleanConstructor;
     handleResize: {
         type: BooleanConstructor;
         default: boolean;
+        description: string;
+    };
+    instantMove: {
+        type: BooleanConstructor;
+        description: string;
+    };
+    eagerMount: {
+        type: BooleanConstructor;
+        description: string;
+    };
+    popperClass: {
+        type: (ArrayConstructor | ObjectConstructor | StringConstructor)[];
+        description: string;
+    };
+    computeTransformOrigin: {
+        type: BooleanConstructor;
+        description: string;
     };
-    instantMove: BooleanConstructor;
-    eagerMount: BooleanConstructor;
-    popperClass: (ArrayConstructor | ObjectConstructor | StringConstructor)[];
-    computeTransformOrigin: BooleanConstructor;
 };
 export type PopoverProps = ExtractPublicPropTypes<typeof popoverProps>;
 type InternalClasses = 'wrapper' | 'content';
 export interface PopoverTheme extends ThemeComponent<PopoverProps, InternalClasses> {
 }
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    disabled: BooleanConstructor;
-    positioningDisabled: BooleanConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        description: string;
+    };
+    positioningDisabled: {
+        type: BooleanConstructor;
+        description: string;
+    };
     placement: {
         type: PropType<Placement>;
         default: string;
+        description: string;
     };
     delay: {
         type: PropType<string | number | {
@@ -72,55 +132,108 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
             hide: number;
         }>;
         default: number;
+        description: string;
+    };
+    distance: {
+        type: (StringConstructor | NumberConstructor)[];
+        description: string;
+    };
+    skidding: {
+        type: (StringConstructor | NumberConstructor)[];
+        description: string;
     };
-    distance: (StringConstructor | NumberConstructor)[];
-    skidding: (StringConstructor | NumberConstructor)[];
     triggers: {
         type: PropType<TriggerEvent[]>;
         default: () => string[];
+        description: string;
     };
     hideArrow: {
         type: BooleanConstructor;
         default: boolean;
+        description: string;
+    };
+    showTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
+        description: string;
+    };
+    hideTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
+        description: string;
+    };
+    popperTriggers: {
+        type: PropType<TriggerEvent[]>;
+        description: string;
+    };
+    popperShowTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
+        description: string;
+    };
+    popperHideTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
+        description: string;
     };
-    showTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
-    hideTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
-    popperTriggers: PropType<TriggerEvent[]>;
-    popperShowTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
-    popperHideTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
     container: {
         type: (BooleanConstructor | ObjectConstructor | StringConstructor)[];
         default: string;
+        description: string;
+    };
+    boundary: {
+        type: (ObjectConstructor | StringConstructor)[];
+        description: string;
     };
-    boundary: (ObjectConstructor | StringConstructor)[];
     strategy: {
         type: PropType<"absolute" | "fixed">;
         default: string;
+        description: string;
     };
     autoHide: {
         type: PropType<boolean | ((event: Event) => boolean)>;
         default: boolean;
+        description: string;
+    };
+    shown: {
+        type: BooleanConstructor;
+        description: string;
     };
-    shown: BooleanConstructor;
     handleResize: {
         type: BooleanConstructor;
         default: boolean;
+        description: string;
+    };
+    instantMove: {
+        type: BooleanConstructor;
+        description: string;
+    };
+    eagerMount: {
+        type: BooleanConstructor;
+        description: string;
+    };
+    popperClass: {
+        type: (ArrayConstructor | ObjectConstructor | StringConstructor)[];
+        description: string;
+    };
+    computeTransformOrigin: {
+        type: BooleanConstructor;
+        description: string;
     };
-    instantMove: BooleanConstructor;
-    eagerMount: BooleanConstructor;
-    popperClass: (ArrayConstructor | ObjectConstructor | StringConstructor)[];
-    computeTransformOrigin: BooleanConstructor;
 }>, {
     show: () => void;
     hide: () => void;
     toggle: () => void;
     isOpen: import("vue").Ref<boolean, boolean>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("resize" | "show" | "hide" | "update:shown" | "apply-show" | "apply-hide" | "close-group" | "close-directive" | "auto-hide")[], "resize" | "show" | "hide" | "update:shown" | "apply-show" | "apply-hide" | "close-group" | "close-directive" | "auto-hide", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    disabled: BooleanConstructor;
-    positioningDisabled: BooleanConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        description: string;
+    };
+    positioningDisabled: {
+        type: BooleanConstructor;
+        description: string;
+    };
     placement: {
         type: PropType<Placement>;
         default: string;
+        description: string;
     };
     delay: {
         type: PropType<string | number | {
@@ -128,44 +241,90 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
             hide: number;
         }>;
         default: number;
+        description: string;
+    };
+    distance: {
+        type: (StringConstructor | NumberConstructor)[];
+        description: string;
+    };
+    skidding: {
+        type: (StringConstructor | NumberConstructor)[];
+        description: string;
     };
-    distance: (StringConstructor | NumberConstructor)[];
-    skidding: (StringConstructor | NumberConstructor)[];
     triggers: {
         type: PropType<TriggerEvent[]>;
         default: () => string[];
+        description: string;
     };
     hideArrow: {
         type: BooleanConstructor;
         default: boolean;
+        description: string;
+    };
+    showTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
+        description: string;
+    };
+    hideTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
+        description: string;
+    };
+    popperTriggers: {
+        type: PropType<TriggerEvent[]>;
+        description: string;
+    };
+    popperShowTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
+        description: string;
+    };
+    popperHideTriggers: {
+        type: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
+        description: string;
     };
-    showTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
-    hideTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
-    popperTriggers: PropType<TriggerEvent[]>;
-    popperShowTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
-    popperHideTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
     container: {
         type: (BooleanConstructor | ObjectConstructor | StringConstructor)[];
         default: string;
+        description: string;
+    };
+    boundary: {
+        type: (ObjectConstructor | StringConstructor)[];
+        description: string;
     };
-    boundary: (ObjectConstructor | StringConstructor)[];
     strategy: {
         type: PropType<"absolute" | "fixed">;
         default: string;
+        description: string;
     };
     autoHide: {
         type: PropType<boolean | ((event: Event) => boolean)>;
         default: boolean;
+        description: string;
+    };
+    shown: {
+        type: BooleanConstructor;
+        description: string;
     };
-    shown: BooleanConstructor;
     handleResize: {
         type: BooleanConstructor;
         default: boolean;
+        description: string;
+    };
+    instantMove: {
+        type: BooleanConstructor;
+        description: string;
+    };
+    eagerMount: {
+        type: BooleanConstructor;
+        description: string;
+    };
+    popperClass: {
+        type: (ArrayConstructor | ObjectConstructor | StringConstructor)[];
+        description: string;
+    };
+    computeTransformOrigin: {
+        type: BooleanConstructor;
+        description: string;
     };
-    instantMove: BooleanConstructor;
-    eagerMount: BooleanConstructor;
-    popperClass: (ArrayConstructor | ObjectConstructor | StringConstructor)[];
-    computeTransformOrigin: BooleanConstructor;
 }>> & Readonly<{
     onResize?: ((...args: any[]) => any) | undefined;
     onShow?: ((...args: any[]) => any) | undefined;

package/lib/components/popover/Popover.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,280 @@
+import { injectButtonGroupKey as e } from "../../composables/keys.js";
+import { useTheme as t } from "../../composables/useTheme.js";
+import { kt as n } from "../../node_modules/.pnpm/floating-vue@5.2.2_@nuxt_kit@4.4.6_magicast@0.5.3__vue@3.5.34_typescript@5.2.2_/node_modules/floating-vue/dist/floating-vue.js";
+import r from "./PopoverContentBoundary.js";
+import { computed as i, createBlock as a, createVNode as o, defineComponent as s, inject as c, normalizeClass as l, normalizeStyle as u, openBlock as d, ref as f, renderSlot as p, unref as m, withCtx as h } from "vue";
+//#region src/components/popover/Popover.vue?vue&type=script&setup=true&lang.ts
+var g = /* @__PURE__ */ s({
+	name: "XPopover",
+	validators: { placement: [
+		"top",
+		"top-start",
+		"top-end",
+		"bottom",
+		"bottom-start",
+		"bottom-end",
+		"left",
+		"left-start",
+		"left-end",
+		"right",
+		"right-start",
+		"right-end"
+	] },
+	docs: {
+		slots: {
+			default: "Trigger element.",
+			content: "Popover panel content."
+		},
+		emits: {
+			show: "Emitted when the popover starts opening.",
+			hide: "Emitted when the popover starts closing.",
+			"update:shown": "Emitted when open state changes.",
+			"apply-show": "Emitted after the show transition is applied.",
+			"apply-hide": "Emitted after the hide transition is applied.",
+			"close-group": "Emitted when a popover group close is requested.",
+			"close-directive": "Emitted when closed via the close directive.",
+			"auto-hide": "Emitted when auto-hide closes the popover.",
+			resize: "Emitted when popover content is resized."
+		},
+		methods: {
+			show: "Show the popover.",
+			hide: "Hide the popover.",
+			toggle: "Toggle open state."
+		}
+	},
+	props: {
+		disabled: {
+			type: Boolean,
+			description: "Disables showing the popover."
+		},
+		positioningDisabled: {
+			type: Boolean,
+			description: "Keeps the popover in the DOM flow without floating positioning."
+		},
+		placement: {
+			type: String,
+			default: "bottom-start",
+			description: "Preferred placement relative to the trigger."
+		},
+		delay: {
+			type: [
+				String,
+				Number,
+				Object
+			],
+			default: 0,
+			description: "Show/hide delay in ms, or `{ show, hide }`."
+		},
+		distance: {
+			type: [Number, String],
+			description: "Offset along the placement axis in pixels."
+		},
+		skidding: {
+			type: [Number, String],
+			description: "Offset along the trigger edge in pixels."
+		},
+		triggers: {
+			type: Array,
+			default: () => ["click"],
+			description: "Events that toggle the popover (for example click, hover, focus)."
+		},
+		hideArrow: {
+			type: Boolean,
+			default: !0,
+			description: "Hides the popover arrow."
+		},
+		showTriggers: {
+			type: [Array, Function],
+			description: "Events that show the popover, or a function deriving them from `triggers`."
+		},
+		hideTriggers: {
+			type: [Array, Function],
+			description: "Events that hide the popover, or a function deriving them from `triggers`."
+		},
+		popperTriggers: {
+			type: Array,
+			description: "Events on the popover content that keep it open."
+		},
+		popperShowTriggers: {
+			type: [Array, Function],
+			description: "Events on the content that show the popover."
+		},
+		popperHideTriggers: {
+			type: [Array, Function],
+			description: "Events on the content that hide the popover."
+		},
+		container: {
+			type: [
+				String,
+				Object,
+				Boolean
+			],
+			default: "body",
+			description: "Element that contains the floating popover DOM."
+		},
+		boundary: {
+			type: [String, Object],
+			description: "Overflow boundary used for flip/shift positioning."
+		},
+		strategy: {
+			type: String,
+			default: "absolute",
+			description: "CSS position strategy for the floating element."
+		},
+		autoHide: {
+			type: [Boolean, Function],
+			default: !0,
+			description: "Hides on outside click, or a predicate deciding whether to hide."
+		},
+		shown: {
+			type: Boolean,
+			description: "Controlled open state."
+		},
+		handleResize: {
+			type: Boolean,
+			default: !0,
+			description: "Repositions when the popover content size changes."
+		},
+		instantMove: {
+			type: Boolean,
+			description: "Skips transition when the popover moves between placements."
+		},
+		eagerMount: {
+			type: Boolean,
+			description: "Mounts popover content immediately instead of on first open."
+		},
+		popperClass: {
+			type: [
+				String,
+				Array,
+				Object
+			],
+			description: "Extra class(es) on the floating popover element."
+		},
+		computeTransformOrigin: {
+			type: Boolean,
+			description: "Computes transform-origin for scale transitions."
+		}
+	},
+	emits: [
+		"show",
+		"hide",
+		"update:shown",
+		"apply-show",
+		"apply-hide",
+		"close-group",
+		"close-directive",
+		"auto-hide",
+		"resize"
+	],
+	setup(s, { expose: g }) {
+		let _ = {
+			isButtonGroup: !1,
+			groupProps: {},
+			registerChild: () => {},
+			unregisterChild: () => {},
+			getPosition: () => "only",
+			childOrder: i(() => [])
+		}, v = s, y = f(null);
+		function b() {
+			y.value?.show();
+		}
+		function x() {
+			y.value?.hide();
+		}
+		function S() {
+			C.value ? x() : b();
+		}
+		let C = f(!1);
+		g({
+			show: b,
+			hide: x,
+			toggle: S,
+			isOpen: C
+		});
+		let w = c(e, _), { styles: T, classes: E, className: D } = t("Popover", {}, v);
+		return (e, t) => (d(), a(m(n), {
+			ref_key: "elRef",
+			ref: y,
+			style: u(m(T)),
+			class: l([
+				m(D),
+				m(E).wrapper,
+				{ "inline-flex self-stretch": m(w).isButtonGroup }
+			]),
+			"positioning-disabled": e.positioningDisabled,
+			placement: e.placement,
+			disabled: e.disabled,
+			delay: e.delay,
+			shown: e.shown,
+			distance: e.distance,
+			skidding: e.skidding,
+			triggers: e.triggers,
+			"show-triggers": e.showTriggers,
+			"hide-triggers": e.hideTriggers,
+			"popper-triggers": e.popperTriggers,
+			"popper-show-triggers": e.popperShowTriggers,
+			"popper-hide-triggers": e.popperHideTriggers,
+			container: e.container,
+			boundary: e.boundary,
+			strategy: e.strategy,
+			"auto-hide": e.autoHide,
+			"handle-resize": e.handleResize,
+			"instant-move": e.instantMove,
+			"eager-mount": e.eagerMount,
+			"popper-class": [
+				m(E).content,
+				e.popperClass,
+				e.hideArrow ? "v-popper__popper--no-arrow" : ""
+			],
+			"compute-transform-origin": e.computeTransformOrigin,
+			onShow: t[0] ||= () => {
+				C.value = !0, e.$emit("show");
+			},
+			onHide: t[1] ||= () => {
+				C.value = !1, e.$emit("hide");
+			},
+			"onUpdate:shown": t[2] ||= (t) => e.$emit("update:shown", t),
+			onApplyShow: t[3] ||= () => e.$emit("apply-show"),
+			onApplyHide: t[4] ||= () => e.$emit("apply-hide"),
+			onCloseGroup: t[5] ||= () => e.$emit("close-group"),
+			onCloseDirective: t[6] ||= () => e.$emit("close-directive"),
+			onAutoHide: t[7] ||= () => e.$emit("auto-hide"),
+			onResize: t[8] ||= () => e.$emit("resize")
+		}, {
+			popper: h(() => [o(r, null, {
+				default: h(() => [p(e.$slots, "content")]),
+				_: 3
+			})]),
+			default: h(() => [p(e.$slots, "default")]),
+			_: 3
+		}, 8, [
+			"style",
+			"class",
+			"positioning-disabled",
+			"placement",
+			"disabled",
+			"delay",
+			"shown",
+			"distance",
+			"skidding",
+			"triggers",
+			"show-triggers",
+			"hide-triggers",
+			"popper-triggers",
+			"popper-show-triggers",
+			"popper-hide-triggers",
+			"container",
+			"boundary",
+			"strategy",
+			"auto-hide",
+			"handle-resize",
+			"instant-move",
+			"eager-mount",
+			"popper-class",
+			"compute-transform-origin"
+		]));
+	}
+});
+//#endregion
+export { g as default };

package/lib/components/popover/PopoverContainer.js

@@ -0,0 +1,5 @@
+import e from "./PopoverContainer.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/popover/PopoverContainer.vue
+var t = e;
+//#endregion
+export { t as default };

package/lib/components/popover/PopoverContainer.vue.d.ts

@@ -4,6 +4,7 @@ declare const popoverContainerProps: {
     tag: {
         default: string;
         type: StringConstructor;
+        description: string;
     };
 };
 export type PopoverContainerProps = ExtractPublicPropTypes<typeof popoverContainerProps>;
@@ -14,11 +15,13 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     tag: {
         default: string;
         type: StringConstructor;
+        description: string;
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     tag: {
         default: string;
         type: StringConstructor;
+        description: string;
     };
 }>> & Readonly<{}>, {
     tag: string;

package/lib/components/popover/PopoverContainer.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,24 @@
+import { useTheme as e } from "../../composables/useTheme.js";
+import { createBlock as t, defineComponent as n, normalizeClass as r, normalizeStyle as i, openBlock as a, renderSlot as o, resolveDynamicComponent as s, unref as c, withCtx as l } from "vue";
+//#region src/components/popover/PopoverContainer.vue?vue&type=script&setup=true&lang.ts
+var u = /* @__PURE__ */ n({
+	name: "XPopoverContainer",
+	docs: { slots: { default: "Styled container content for popover panels." } },
+	props: { tag: {
+		default: "div",
+		type: String,
+		description: "Root element tag."
+	} },
+	setup(n) {
+		let { styles: u, classes: d, className: f } = e("PopoverContainer", {}, n);
+		return (e, n) => (a(), t(s(e.tag), {
+			style: i(c(u)),
+			class: r([c(f), c(d).wrapper])
+		}, {
+			default: l(() => [o(e.$slots, "default")]),
+			_: 3
+		}, 8, ["style", "class"]));
+	}
+});
+//#endregion
+export { u as default };