@unergy-dev/gandalf 0.0.0-stage → 0.6.0

package/dist/components/gandalf/kit/report/Pin.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,51 @@
+import { cn } from "../../../../lib/utils.js";
+import CircleReport_default from "./CircleReport.js";
+import { createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, normalizeClass, openBlock, renderSlot, toDisplayString, unref } from "vue";
+// src/components/gandalf/kit/report/Pin.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 0,
+	class: "text-body-smEm text-base-foreground whitespace-nowrap"
+};
+var _hoisted_2 = { class: "relative block h-[41px] w-[34px] shrink-0 [filter:drop-shadow(0_4px_3px_rgb(0_0_0/0.1))_drop-shadow(0_2px_2px_rgb(0_0_0/0.1))]" };
+var _hoisted_3 = { class: "bg-card absolute top-0 left-0 flex rounded-full p-0.5" };
+var Pin_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "Pin",
+	props: {
+		layerName: { default: "Layer name" },
+		showLayerName: {
+			type: Boolean,
+			default: true
+		},
+		report: { default: "access" },
+		class: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: void 0
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				"data-slot": "pin",
+				class: normalizeClass(unref(cn)("inline-flex flex-col items-center gap-1", props.class))
+			}, [__props.showLayerName ? (openBlock(), createElementBlock("span", _hoisted_1, [renderSlot(_ctx.$slots, "layer-name", {}, () => [createTextVNode(toDisplayString(__props.layerName), 1)])])) : createCommentVNode("", true), createElementVNode("span", _hoisted_2, [_cache[0] || (_cache[0] = createElementVNode("svg", {
+				class: "absolute top-[15px] left-px",
+				width: "32",
+				height: "26",
+				viewBox: "0 0 32 26",
+				fill: "none",
+				"aria-hidden": "true"
+			}, [createElementVNode("path", {
+				d: "M32 7.68182C31.4483 10.6364 23.313 26 16 26C8.68699 26 0.551724 10.6364 0 7.68203C0 -0.150377 8.68699 0.000207291 16 0.000207291C23.313 0.000207291 32 -0.150584 32 7.68182Z",
+				fill: "white"
+			})], -1)), createElementVNode("span", _hoisted_3, [renderSlot(_ctx.$slots, "default", {}, () => [createVNode(CircleReport_default, { type: __props.report }, null, 8, ["type"])])])])], 2);
+		};
+	}
+});
+export { Pin_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/gandalf/kit/report/index.d.ts

@@ -0,0 +1,24 @@
+import { VariantProps } from 'class-variance-authority';
+import { Component } from 'vue';
+export { default as GCircleReport } from './CircleReport.vue';
+export { default as GAvatarReport } from './AvatarReport.vue';
+export { default as GPin } from './Pin.vue';
+export { default as GIcons } from './Icons.vue';
+export { default as GPickerItem } from './PickerItem.vue';
+export declare const gandalfCircleReportVariants: (props?: ({
+    type?: "access" | "boundary" | "pole" | "road" | "soil" | "fustal" | "latizal" | "agua" | "otro" | "observacion" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type GandalfCircleReportType = NonNullable<VariantProps<typeof gandalfCircleReportVariants>['type']>;
+export declare const circleReportIcons: Record<GandalfCircleReportType, Component>;
+export declare const gandalfAvatarReportVariants: (props?: ({
+    type?: "access" | "boundary" | "pole" | "road" | "soil" | "fustal" | "latizal" | "agua" | "otro" | "poligono" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type GandalfAvatarReportType = NonNullable<VariantProps<typeof gandalfAvatarReportVariants>['type']>;
+export declare const avatarReportIcons: Record<GandalfAvatarReportType, Component>;
+export declare const gandalfIconsVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const GANDALF_ICONS_TYPES: readonly ["pin", "tree", "door", "pole"];
+export type GandalfIconsType = (typeof GANDALF_ICONS_TYPES)[number];
+export declare const gandalfPickerItemVariants: (props?: ({
+    type?: "label" | "icon" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type GandalfPickerItemType = NonNullable<VariantProps<typeof gandalfPickerItemVariants>['type']>;

package/dist/components/gandalf/kit/report/index.js

@@ -0,0 +1,77 @@
+import CircleReport_default from "./CircleReport.js";
+import AvatarReport_default from "./AvatarReport.js";
+import Pin_default from "./Pin.js";
+import Icons_default from "./Icons.js";
+import PickerItem_default from "./PickerItem.js";
+import { cva } from "class-variance-authority";
+import { CircleQuestionMark, CornerUpRight, DoorOpen, Droplet, Grid2x2, ScanEye, Sprout, TreePine, UtilityPole, VectorSquare, Waypoints, Zap } from "lucide-vue-next";
+// src/components/gandalf/kit/report/index.ts
+var gandalfCircleReportVariants = cva("inline-flex size-[30px] shrink-0 items-center justify-center rounded-full p-0.5 [&_svg]:size-4", {
+	variants: { type: {
+		access: "bg-orange-600 text-orange-50",
+		boundary: "bg-red-600 text-red-50",
+		pole: "bg-amber-600 text-amber-50",
+		road: "bg-indigo-600 text-indigo-50",
+		soil: "bg-pink-600 text-pink-50",
+		fustal: "bg-green-600 text-gray-50",
+		latizal: "bg-emerald-600 text-emerald-50",
+		agua: "bg-blue-600 text-blue-50",
+		otro: "bg-purple-600 text-purple-50",
+		observacion: "bg-orange-600 text-purple-50"
+	} },
+	defaultVariants: { type: "access" }
+});
+var circleReportIcons = {
+	access: DoorOpen,
+	boundary: VectorSquare,
+	pole: UtilityPole,
+	road: CornerUpRight,
+	soil: Grid2x2,
+	fustal: TreePine,
+	latizal: Sprout,
+	agua: Droplet,
+	otro: CircleQuestionMark,
+	observacion: ScanEye
+};
+var gandalfAvatarReportVariants = cva("items-center justify-center [&_svg]:size-3", {
+	variants: { type: {
+		access: "bg-orange-100 text-orange-700",
+		boundary: "bg-red-100 text-red-700",
+		pole: "bg-amber-100 text-amber-700",
+		road: "bg-indigo-100 text-indigo-700",
+		soil: "bg-pink-100 text-pink-700",
+		fustal: "bg-green-100 text-green-700",
+		latizal: "bg-emerald-100 text-emerald-700",
+		agua: "bg-blue-100 text-blue-700",
+		otro: "bg-purple-100 text-purple-700",
+		poligono: "bg-default-muted text-default-bold"
+	} },
+	defaultVariants: { type: "access" }
+});
+var avatarReportIcons = {
+	access: DoorOpen,
+	boundary: VectorSquare,
+	pole: Zap,
+	road: CornerUpRight,
+	soil: Grid2x2,
+	fustal: TreePine,
+	latizal: Sprout,
+	agua: Droplet,
+	otro: CircleQuestionMark,
+	poligono: Waypoints
+};
+var gandalfIconsVariants = cva("flex h-8 w-11 shrink-0 flex-col items-center justify-center overflow-clip p-2.5");
+var GANDALF_ICONS_TYPES = [
+	"pin",
+	"tree",
+	"door",
+	"pole"
+];
+var gandalfPickerItemVariants = cva("focus-visible:ring-ring hover:not-data-[state=on]:overlay-dark-5 active:not-data-[state=on]:overlay-dark-8 data-[state=on]:border-accent-primary-foreground data-[state=on]:bg-accent-primary inline-flex shrink-0 cursor-pointer items-center justify-center overflow-clip rounded-md border-[1.5px] border-transparent outline-none focus-visible:ring-2 disabled:cursor-not-allowed disabled:opacity-50", {
+	variants: { type: {
+		icon: "h-8 w-11 flex-col",
+		label: "h-8 w-[86px] gap-1.5 px-2"
+	} },
+	defaultVariants: { type: "icon" }
+});
+export { GANDALF_ICONS_TYPES, AvatarReport_default as GAvatarReport, CircleReport_default as GCircleReport, Icons_default as GIcons, PickerItem_default as GPickerItem, Pin_default as GPin, avatarReportIcons, circleReportIcons, gandalfAvatarReportVariants, gandalfCircleReportVariants, gandalfIconsVariants, gandalfPickerItemVariants };

package/dist/components/gandalf/kit/search-field/SearchField.js

@@ -0,0 +1,4 @@
+import SearchField_vue_vue_type_script_setup_true_lang_default from "./SearchField.vue_vue_type_script_setup_true_lang.js";
+// src/components/gandalf/kit/search-field/SearchField.vue
+var SearchField_default = SearchField_vue_vue_type_script_setup_true_lang_default;
+export { SearchField_default as default };

package/dist/components/gandalf/kit/search-field/SearchField.vue.d.ts

@@ -0,0 +1,27 @@
+import { HTMLAttributes } from 'vue';
+import { GandalfSearchFieldSize } from './index';
+type __VLS_Props = {
+    modelValue?: string;
+    placeholder?: string;
+    size?: GandalfSearchFieldSize;
+    disabled?: boolean;
+    /** Accessible name of the clear button. */
+    clearLabel?: string;
+    class?: HTMLAttributes['class'];
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    clear: () => any;
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: string;
+    size: GandalfSearchFieldSize;
+    placeholder: string;
+    class: string | false | Record<string, any> | import('vue').ClassValue[] | null;
+    clearLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/gandalf/kit/search-field/SearchField.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,72 @@
+import { cn } from "../../../../lib/utils.js";
+import { gandalfFieldWithinClass } from "../../base/input/index.js";
+import { gandalfSearchFieldVariants } from "./index.js";
+import { createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, openBlock, unref } from "vue";
+import { Search, X } from "lucide-vue-next";
+// src/components/gandalf/kit/search-field/SearchField.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = [
+	"value",
+	"placeholder",
+	"disabled"
+];
+var _hoisted_2 = ["aria-label"];
+var SearchField_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	inheritAttrs: false,
+	__name: "SearchField",
+	props: {
+		modelValue: { default: "" },
+		placeholder: { default: "Search" },
+		size: { default: "md" },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		clearLabel: { default: "Clear search" },
+		class: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: void 0
+		}
+	},
+	emits: ["update:modelValue", "clear"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		function clear() {
+			emit("update:modelValue", "");
+			emit("clear");
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				"data-slot": "search-field",
+				class: normalizeClass(unref(cn)(unref(gandalfFieldWithinClass), unref(gandalfSearchFieldVariants)({ size: __props.size }), props.class))
+			}, [
+				createVNode(unref(Search), {
+					class: "shrink-0",
+					"aria-hidden": "true"
+				}),
+				createElementVNode("input", mergeProps(_ctx.$attrs, {
+					type: "search",
+					value: __props.modelValue,
+					placeholder: __props.placeholder,
+					disabled: __props.disabled,
+					class: "placeholder:text-base-foreground-extra-quiet min-w-0 flex-1 bg-transparent outline-none [&::-webkit-search-cancel-button]:hidden",
+					onInput: _cache[0] || (_cache[0] = ($event) => emit("update:modelValue", $event.target.value))
+				}), null, 16, _hoisted_1),
+				__props.modelValue && !__props.disabled ? (openBlock(), createElementBlock("button", {
+					key: 0,
+					type: "button",
+					class: "focus-visible:ring-ring shrink-0 cursor-pointer rounded-sm outline-none focus-visible:ring-2",
+					"aria-label": __props.clearLabel,
+					onClick: clear
+				}, [createVNode(unref(X))], 8, _hoisted_2)) : createCommentVNode("", true)
+			], 2);
+		};
+	}
+});
+export { SearchField_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/gandalf/kit/search-field/index.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+export { default as GSearchField } from './SearchField.vue';
+export declare const gandalfSearchFieldVariants: (props?: ({
+    size?: "md" | "sm" | "xs" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type GandalfSearchFieldVariants = VariantProps<typeof gandalfSearchFieldVariants>;
+export type GandalfSearchFieldSize = NonNullable<GandalfSearchFieldVariants['size']>;

package/dist/components/gandalf/kit/search-field/index.js

@@ -0,0 +1,12 @@
+import SearchField_default from "./SearchField.js";
+import { cva } from "class-variance-authority";
+// src/components/gandalf/kit/search-field/index.ts
+var gandalfSearchFieldVariants = cva("flex w-full items-center", {
+	variants: { size: {
+		xs: "h-6 gap-1.5 px-2 text-xs [&_svg]:size-3",
+		sm: "h-8 gap-2 px-3 text-xs [&_svg]:size-3.5",
+		md: "h-10 gap-2 px-3 text-base [&_svg]:size-4"
+	} },
+	defaultVariants: { size: "md" }
+});
+export { SearchField_default as GSearchField, gandalfSearchFieldVariants };

package/dist/components/gandalf/kit/select/Select.js

@@ -0,0 +1,4 @@
+import Select_vue_vue_type_script_setup_true_lang_default from "./Select.vue_vue_type_script_setup_true_lang.js";
+// src/components/gandalf/kit/select/Select.vue
+var Select_default = Select_vue_vue_type_script_setup_true_lang_default;
+export { Select_default as default };

package/dist/components/gandalf/kit/select/Select.vue.d.ts

@@ -0,0 +1,79 @@
+import { HTMLAttributes } from 'vue';
+import { SelectModelValue, SelectOption, SelectOptions } from './types';
+type __VLS_Props = {
+    /** The list to choose from, flat or grouped. */
+    options: SelectOptions;
+    /** Allows selecting more than one option. `modelValue` becomes an array. */
+    multiple?: boolean;
+    /** Shown on the trigger while nothing is selected. */
+    placeholder?: string;
+    /** Shown in place of the list when `options` is empty. */
+    emptyMessage?: string;
+    /** Blocks the trigger. */
+    disabled?: boolean;
+    /** Adds a clear control to the trigger once something is selected. */
+    clearable?: boolean;
+    /** Accessible label for the clear control. */
+    clearLabel?: string;
+    /** Renders a spinner in place of the list. */
+    loading?: boolean;
+    /** Submits with a surrounding form, as a native hidden select. */
+    name?: string;
+    /** Marks the hidden select required. Only meaningful alongside `name`. */
+    required?: boolean;
+    /** How many badges the trigger shows before collapsing into a counter. `multiple` only. */
+    maxDisplay?: number;
+    /** Trigger height, as Figma's Input Field: `default` is md (40px), `sm` is 32px. */
+    size?: 'sm' | 'default';
+    /** Merged onto the trigger. */
+    class?: HTMLAttributes['class'];
+    /** Merged onto the popover content. */
+    contentClass?: HTMLAttributes['class'];
+};
+type __VLS_ModelProps = {
+    modelValue?: SelectModelValue;
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_54: {}, __VLS_61: {}, __VLS_84: {
+    option: SelectOption;
+    selected: boolean;
+};
+type __VLS_Slots = {} & {
+    loading?: (props: typeof __VLS_54) => any;
+} & {
+    empty?: (props: typeof __VLS_61) => any;
+} & {
+    option?: (props: typeof __VLS_84) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: SelectModelValue) => any;
+    select: (option: SelectOption) => any;
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: SelectModelValue) => any) | undefined;
+    onSelect?: ((option: SelectOption) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: "default" | "sm";
+    multiple: boolean;
+    placeholder: string;
+    class: string | false | Record<string, any> | import('vue').ClassValue[] | null;
+    name: string;
+    required: boolean;
+    contentClass: string | false | Record<string, any> | import('vue').ClassValue[] | null;
+    clearable: boolean;
+    clearLabel: string;
+    emptyMessage: string;
+    loading: boolean;
+    maxDisplay: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/gandalf/kit/select/Select.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,238 @@
+import { cn } from "../../../../lib/utils.js";
+import GBadge_default from "../../base/badge/GBadge.js";
+import GButton_default from "../../base/button/GButton.js";
+import { gandalfMenuCheckItemVariants } from "../../base/menu/index.js";
+import { gandalfFieldPlaceholderClass } from "../../base/input/index.js";
+import GSelect_default from "../../base/select/GSelect.js";
+import GSelectTrigger_default from "../../base/select/GSelectTrigger.js";
+import GSelectValue_default from "../../base/select/GSelectValue.js";
+import GSelectContent_default from "../../base/select/GSelectContent.js";
+import GSelectGroup_default from "../../base/select/GSelectGroup.js";
+import GSelectLabel_default from "../../base/select/GSelectLabel.js";
+import GSelectItem_default from "../../base/select/GSelectItem.js";
+import { flatten, toGroups } from "./options.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createTextVNode, createVNode, defineComponent, mergeModels, normalizeClass, normalizeStyle, openBlock, renderList, renderSlot, toDisplayString, unref, useModel, withCtx, withModifiers } from "vue";
+import { LoaderCircle, X } from "lucide-vue-next";
+// src/components/gandalf/kit/select/Select.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "relative w-full" };
+var _hoisted_2 = { class: "min-w-0 truncate" };
+var _hoisted_3 = {
+	key: 0,
+	class: "flex items-center justify-center py-6"
+};
+var _hoisted_4 = {
+	key: 1,
+	class: "text-muted-foreground py-6 text-center text-sm"
+};
+var _hoisted_5 = {
+	key: 1,
+	class: "flex min-w-0 flex-col"
+};
+var _hoisted_6 = { class: "truncate" };
+var _hoisted_7 = { class: "text-muted-foreground truncate text-xs" };
+var _hoisted_8 = {
+	key: 2,
+	class: "truncate"
+};
+var Select_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "Select",
+	props: /*@__PURE__*/ mergeModels({
+		options: {},
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+		placeholder: { default: "Select an option..." },
+		emptyMessage: { default: "No options available." },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		clearable: {
+			type: Boolean,
+			default: false
+		},
+		clearLabel: { default: "Clear selection" },
+		loading: {
+			type: Boolean,
+			default: false
+		},
+		name: { default: void 0 },
+		required: {
+			type: Boolean,
+			default: false
+		},
+		maxDisplay: { default: 3 },
+		size: { default: "default" },
+		class: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: void 0
+		},
+		contentClass: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: void 0
+		}
+	}, {
+		"modelValue": { default: void 0 },
+		"modelModifiers": {},
+		"open": {
+			type: Boolean,
+			default: false
+		},
+		"openModifiers": {}
+	}),
+	emits: /*@__PURE__*/ mergeModels(["select"], ["update:modelValue", "update:open"]),
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const modelValue = useModel(__props, "modelValue");
+		const open = useModel(__props, "open");
+		const groups = computed(() => toGroups(props.options));
+		const all = computed(() => flatten(props.options));
+		/** The selection as an array, whether `multiple` or not, so one code path handles both. */
+		const values = computed(() => {
+			const value = modelValue.value;
+			if (value === void 0 || value === null) return [];
+			return Array.isArray(value) ? value : [value];
+		});
+		const selected = computed(() => all.value.filter((option) => values.value.includes(option.value)));
+		const shown = computed(() => selected.value.slice(0, props.maxDisplay));
+		const overflow = computed(() => Math.max(0, selected.value.length - props.maxDisplay));
+		const showClear = computed(() => props.clearable && !props.disabled && selected.value.length > 0);
+		/**
+		* Reka has no select event of its own, so the changed row is worked out by diffing. Watching
+		* `modelValue` instead would also fire on mount and on every programmatic assignment, announcing
+		* a selection nobody made.
+		*/
+		function handleUpdate(next) {
+			const before = values.value;
+			modelValue.value = next;
+			const after = Array.isArray(next) ? next : next === void 0 || next === null ? [] : [next];
+			const changed = after.find((value) => !before.includes(value)) ?? before.find((value) => !after.includes(value));
+			const option = all.value.find((candidate) => candidate.value === changed);
+			if (option) emit("select", option);
+		}
+		function clear() {
+			modelValue.value = props.multiple ? [] : void 0;
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(GSelect_default), {
+				"model-value": modelValue.value,
+				open: open.value,
+				multiple: __props.multiple,
+				disabled: __props.disabled,
+				name: __props.name,
+				required: __props.required,
+				"onUpdate:modelValue": handleUpdate,
+				"onUpdate:open": _cache[0] || (_cache[0] = ($event) => open.value = $event)
+			}, {
+				default: withCtx(() => [createElementVNode("div", _hoisted_1, [createVNode(unref(GSelectTrigger_default), {
+					size: __props.size,
+					class: normalizeClass(unref(cn)("w-full data-[size=default]:h-auto data-[size=sm]:h-auto", __props.size === "sm" ? "min-h-8" : "min-h-10", props.class))
+				}, {
+					default: withCtx(() => [createVNode(unref(GSelectValue_default), {
+						as: "div",
+						placeholder: __props.placeholder,
+						class: normalizeClass(unref(cn)("flex min-w-0 flex-1 flex-wrap items-center gap-1", showClear.value && "pe-7"))
+					}, {
+						default: withCtx(() => [selected.value.length === 0 ? (openBlock(), createElementBlock("span", {
+							key: 0,
+							class: normalizeClass(unref(cn)(unref(gandalfFieldPlaceholderClass), "truncate"))
+						}, toDisplayString(__props.placeholder), 3)) : __props.multiple ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [(openBlock(true), createElementBlock(Fragment, null, renderList(shown.value, (option) => {
+							return openBlock(), createBlock(unref(GBadge_default), {
+								key: option.value,
+								variant: "outlined",
+								color: option.color,
+								size: "xs"
+							}, {
+								default: withCtx(() => [createTextVNode(toDisplayString(option.label), 1)]),
+								_: 2
+							}, 1032, ["color"]);
+						}), 128)), overflow.value > 0 ? (openBlock(), createBlock(unref(GBadge_default), {
+							key: 0,
+							variant: "outlined",
+							size: "xs"
+						}, {
+							default: withCtx(() => [createTextVNode("+" + toDisplayString(overflow.value), 1)]),
+							_: 1
+						})) : createCommentVNode("", true)], 64)) : (openBlock(), createElementBlock(Fragment, { key: 2 }, [selected.value[0]?.color ? (openBlock(), createElementBlock("span", {
+							key: 0,
+							class: "size-2 shrink-0 rounded-full",
+							style: normalizeStyle({ backgroundColor: selected.value[0]?.color })
+						}, null, 4)) : createCommentVNode("", true), createElementVNode("span", _hoisted_2, toDisplayString(selected.value[0]?.label), 1)], 64))]),
+						_: 1
+					}, 8, ["placeholder", "class"])]),
+					_: 1
+				}, 8, ["size", "class"]), showClear.value ? (openBlock(), createBlock(unref(GButton_default), {
+					key: 0,
+					type: "button",
+					variant: "ghost-primary",
+					size: "xs",
+					class: "absolute inset-y-0 inset-e-8 my-auto size-6",
+					"aria-label": __props.clearLabel,
+					onClick: withModifiers(clear, ["stop"])
+				}, {
+					default: withCtx(() => [createVNode(unref(X), { class: "size-4 opacity-50" })]),
+					_: 1
+				}, 8, ["aria-label"])) : createCommentVNode("", true)]), createVNode(unref(GSelectContent_default), { class: normalizeClass(unref(cn)(__props.contentClass)) }, {
+					default: withCtx(() => [__props.loading ? (openBlock(), createElementBlock("div", _hoisted_3, [renderSlot(_ctx.$slots, "loading", {}, () => [createVNode(unref(LoaderCircle), { class: "size-4 animate-spin opacity-50" })])])) : all.value.length === 0 ? (openBlock(), createElementBlock("div", _hoisted_4, [renderSlot(_ctx.$slots, "empty", {}, () => [createTextVNode(toDisplayString(__props.emptyMessage), 1)])])) : (openBlock(true), createElementBlock(Fragment, { key: 2 }, renderList(groups.value, (group, groupIndex) => {
+						return openBlock(), createBlock(unref(GSelectGroup_default), { key: group.label ?? groupIndex }, {
+							default: withCtx(() => [group.label ? (openBlock(), createBlock(unref(GSelectLabel_default), { key: 0 }, {
+								default: withCtx(() => [createTextVNode(toDisplayString(group.label), 1)]),
+								_: 2
+							}, 1024)) : createCommentVNode("", true), (openBlock(true), createElementBlock(Fragment, null, renderList(group.options, (option) => {
+								return openBlock(), createBlock(unref(GSelectItem_default), {
+									key: option.value,
+									value: option.value,
+									disabled: option.disabled,
+									class: normalizeClass(__props.multiple && unref(gandalfMenuCheckItemVariants)())
+								}, createSlots({
+									default: withCtx(() => [renderSlot(_ctx.$slots, "option", {
+										option,
+										selected: values.value.includes(option.value)
+									}, () => [option.color ? (openBlock(), createElementBlock("span", {
+										key: 0,
+										class: "size-2 shrink-0 rounded-full",
+										style: normalizeStyle({ backgroundColor: option.color })
+									}, null, 4)) : createCommentVNode("", true), option.description ? (openBlock(), createElementBlock("span", _hoisted_5, [createElementVNode("span", _hoisted_6, toDisplayString(option.label), 1), createElementVNode("span", _hoisted_7, toDisplayString(option.description), 1)])) : (openBlock(), createElementBlock("span", _hoisted_8, toDisplayString(option.label), 1))])]),
+									_: 2
+								}, [__props.multiple ? {
+									name: "indicator-icon",
+									fn: withCtx(() => [_cache[1] || (_cache[1] = createElementVNode("span", null, null, -1))]),
+									key: "0"
+								} : void 0]), 1032, [
+									"value",
+									"disabled",
+									"class"
+								]);
+							}), 128))]),
+							_: 2
+						}, 1024);
+					}), 128))]),
+					_: 3
+				}, 8, ["class"])]),
+				_: 3
+			}, 8, [
+				"model-value",
+				"open",
+				"multiple",
+				"disabled",
+				"name",
+				"required"
+			]);
+		};
+	}
+});
+export { Select_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/gandalf/kit/select/index.d.ts

@@ -0,0 +1,3 @@
+export { default as GKitSelect } from './Select.vue';
+export { flatten, isGroup, toGroups } from './options';
+export type { SelectModelValue, SelectOption, SelectOptionGroup, SelectOptions, SelectValue, } from './types';

package/dist/components/gandalf/kit/select/options.d.ts

@@ -0,0 +1,18 @@
+import { SelectOption, SelectOptionGroup, SelectOptions } from './types';
+/**
+ * Whether an entry is a group rather than an option.
+ *
+ * Groups are told apart by carrying `options`, so an option may not have a property by that name.
+ * The alternative — a `kind` discriminator — would have to be written on every option by hand,
+ * which is a tax on the common case to make the rare one tidier.
+ */
+export declare function isGroup(entry: SelectOption | SelectOptionGroup): entry is SelectOptionGroup;
+/**
+ * Reads either shape as groups, so the rest of the component only handles one.
+ *
+ * A flat list becomes a single unlabelled group. The first entry decides how the whole array is
+ * read: a mixed array is a caller mistake, and guessing per entry would hide it.
+ */
+export declare function toGroups(options: SelectOptions): SelectOptionGroup[];
+/** Every option, in order, with the grouping discarded. */
+export declare function flatten(options: SelectOptions): SelectOption[];

package/dist/components/gandalf/kit/select/options.js

@@ -0,0 +1,27 @@
+// src/components/gandalf/kit/select/options.ts
+/**
+* Whether an entry is a group rather than an option.
+*
+* Groups are told apart by carrying `options`, so an option may not have a property by that name.
+* The alternative — a `kind` discriminator — would have to be written on every option by hand,
+* which is a tax on the common case to make the rare one tidier.
+*/
+function isGroup(entry) {
+	return entry !== null && typeof entry === "object" && "options" in entry;
+}
+/**
+* Reads either shape as groups, so the rest of the component only handles one.
+*
+* A flat list becomes a single unlabelled group. The first entry decides how the whole array is
+* read: a mixed array is a caller mistake, and guessing per entry would hide it.
+*/
+function toGroups(options) {
+	const first = options[0];
+	if (first === void 0) return [];
+	return isGroup(first) ? options : [{ options }];
+}
+/** Every option, in order, with the grouping discarded. */
+function flatten(options) {
+	return toGroups(options).flatMap((group) => group.options);
+}
+export { flatten, isGroup, toGroups };