@unergy-dev/gandalf 0.0.0-stage → 0.3.0

package/dist/components/gandalf/kit/date-picker/DatePicker.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,310 @@
+import { cn } from "../../../../lib/utils.js";
+import GButton_default from "../../base/button/GButton.js";
+import GCalendar_default from "../../base/calendar/GCalendar.js";
+import { gandalfFieldTriggerClass, gandalfFieldVariants } from "../../base/input/index.js";
+import GPopover_default from "../../base/popover/GPopover.js";
+import GPopoverTrigger_default from "../../base/popover/GPopoverTrigger.js";
+import GPopoverContent_default from "../../base/popover/GPopoverContent.js";
+import GRangeCalendar_default from "../../base/range-calendar/GRangeCalendar.js";
+import { formatDate, formatDateRange, isRange, toCalendarDate, toDateMatcher, toISODate, toNativeDate } from "./date.js";
+import { activePreset, resolvePreset } from "./presets.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, mergeModels, mergeProps, normalizeClass, openBlock, renderList, renderSlot, toDisplayString, unref, useModel, withCtx, withModifiers } from "vue";
+import { CalendarIcon, X } from "lucide-vue-next";
+// src/components/gandalf/kit/date-picker/DatePicker.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "relative w-full" };
+var _hoisted_2 = ["id", "disabled"];
+var _hoisted_3 = ["name", "value"];
+var _hoisted_4 = ["name", "value"];
+var _hoisted_5 = { class: "flex flex-col sm:flex-row" };
+var _hoisted_6 = {
+	key: 0,
+	class: "border-border flex gap-1 overflow-x-auto border-b p-2 sm:w-40 sm:shrink-0 sm:flex-col sm:overflow-visible sm:border-e sm:border-b-0"
+};
+var _hoisted_7 = {
+	key: 0,
+	class: "border-border border-t p-2"
+};
+var DatePicker_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	inheritAttrs: false,
+	__name: "DatePicker",
+	props: /*@__PURE__*/ mergeModels({
+		type: { default: "single" },
+		placeholder: { default: "Select a date..." },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		clearable: {
+			type: Boolean,
+			default: false
+		},
+		clearLabel: { default: "Clear date" },
+		presets: { default: void 0 },
+		min: { default: void 0 },
+		max: { default: void 0 },
+		isDateDisabled: {
+			type: Function,
+			default: void 0
+		},
+		locale: { default: "es-CO" },
+		format: { default: () => ({ dateStyle: "medium" }) },
+		closeOnSelect: {
+			type: Boolean,
+			default: true
+		},
+		name: { default: void 0 },
+		endName: { default: void 0 },
+		serialize: {
+			type: Function,
+			default: toISODate
+		},
+		id: { default: void 0 },
+		align: { default: "start" },
+		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": {},
+		"month": { default: void 0 },
+		"monthModifiers": {}
+	}),
+	emits: /*@__PURE__*/ mergeModels(["change"], [
+		"update:modelValue",
+		"update:open",
+		"update:month"
+	]),
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const modelValue = useModel(__props, "modelValue");
+		const open = useModel(__props, "open");
+		/**
+		* The month on screen — the calendar primitive's `placeholder`, renamed because `placeholder` is
+		* already the trigger's empty text everywhere else in Gandalf. Two props with one name, one a
+		* string and one a date, is a coin flip every caller loses once.
+		*/
+		const month = useModel(__props, "month");
+		const isRangeType = computed(() => props.type === "range");
+		/** The selection as the calendar reads it. */
+		const single = computed(() => isRangeType.value ? void 0 : toCalendarDate(modelValue.value));
+		const range = computed(() => {
+			const value = modelValue.value;
+			const parts = isRange(value) ? value : {};
+			return {
+				start: toCalendarDate(parts.start),
+				end: toCalendarDate(parts.end)
+			};
+		});
+		/** The day the calendar opens on when nothing says otherwise. */
+		const anchor = computed(() => isRangeType.value ? range.value.start : single.value);
+		const monthOnScreen = computed(() => toCalendarDate(month.value) ?? anchor.value ?? toCalendarDate(/* @__PURE__ */ new Date()));
+		const presets = computed(() => props.presets ?? []);
+		const active = computed(() => activePreset(presets.value, modelValue.value));
+		const empty = computed(() => isRangeType.value ? range.value.start === void 0 : single.value === void 0);
+		const label = computed(() => {
+			if (active.value) return active.value.label;
+			if (isRangeType.value) return formatDateRange(asRange(modelValue.value), props.locale, props.format);
+			return formatDate(modelValue.value, props.locale, props.format);
+		});
+		const showClear = computed(() => props.clearable && !props.disabled && !empty.value);
+		/** The converted conveniences, merged over `$attrs` so a named prop wins over a raw calendar one. */
+		const calendarProps = computed(() => ({
+			...props.min !== void 0 ? { minValue: toCalendarDate(props.min) } : {},
+			...props.max !== void 0 ? { maxValue: toCalendarDate(props.max) } : {},
+			...props.isDateDisabled ? { isDateDisabled: toDateMatcher(props.isDateDisabled) } : {}
+		}));
+		const startName = computed(() => props.name);
+		const endFieldName = computed(() => props.endName ?? (props.name ? `${props.name}-end` : void 0));
+		function asRange(value) {
+			return isRange(value) ? value : void 0;
+		}
+		function serialized(value) {
+			const date = toNativeDate(toCalendarDate(value));
+			return date ? props.serialize(date) : "";
+		}
+		function commit(value) {
+			modelValue.value = value;
+			emit("change", value);
+		}
+		function close() {
+			open.value = false;
+		}
+		function handleSingle(next) {
+			commit(toNativeDate(next));
+			if (props.closeOnSelect && next) close();
+		}
+		/**
+		* A range is finished only when the second end lands. Until then the value is written through so
+		* the calendar and the trigger stay honest about the half state, but `change` stays quiet and the
+		* popover stays open — closing on the first click is the classic hand-rolled range picker bug.
+		*/
+		function handleRange(next) {
+			const value = {
+				start: toNativeDate(next?.start),
+				end: toNativeDate(next?.end)
+			};
+			const complete = value.start !== void 0 && value.end !== void 0;
+			const cleared = value.start === void 0 && value.end === void 0;
+			modelValue.value = value;
+			if (complete || cleared) emit("change", value);
+			if (props.closeOnSelect && complete) close();
+		}
+		function applyPreset(preset) {
+			const value = resolvePreset(preset);
+			if (isRangeType.value) {
+				const parts = asRange(value) ?? {};
+				commit({
+					start: toNativeDate(toCalendarDate(parts.start)),
+					end: toNativeDate(toCalendarDate(parts.end))
+				});
+			} else commit(toNativeDate(toCalendarDate(value)));
+			if (props.closeOnSelect) close();
+		}
+		function clear() {
+			commit(isRangeType.value ? {
+				start: void 0,
+				end: void 0
+			} : void 0);
+		}
+		function handleOpenChange(next) {
+			open.value = next;
+			if (!next) month.value = void 0;
+		}
+		function handleMonthChange(next) {
+			month.value = toNativeDate(next);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(GPopover_default), {
+				open: open.value,
+				"onUpdate:open": handleOpenChange
+			}, {
+				default: withCtx(() => [createElementVNode("div", _hoisted_1, [
+					createVNode(unref(GPopoverTrigger_default), { "as-child": "" }, {
+						default: withCtx(() => [renderSlot(_ctx.$slots, "trigger", {
+							value: modelValue.value,
+							label: label.value,
+							empty: empty.value,
+							open: open.value,
+							disabled: __props.disabled,
+							clear
+						}, () => [createElementVNode("button", {
+							id: __props.id,
+							type: "button",
+							disabled: __props.disabled,
+							class: normalizeClass(unref(cn)(unref(gandalfFieldVariants)({ size: __props.size === "sm" ? "sm" : "md" }), unref(gandalfFieldTriggerClass), props.class))
+						}, [createElementVNode("span", { class: normalizeClass(unref(cn)("min-w-0 truncate text-start", empty.value && unref("text-base-foreground-extra-quiet"), showClear.value && "pe-7")) }, toDisplayString(label.value || __props.placeholder), 3), createVNode(unref(CalendarIcon), { class: "size-4 shrink-0 opacity-50" })], 10, _hoisted_2)])]),
+						_: 3
+					}),
+					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),
+					__props.name ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [createElementVNode("input", {
+						type: "hidden",
+						name: startName.value,
+						value: serialized(isRangeType.value ? asRange(modelValue.value)?.start : modelValue.value)
+					}, null, 8, _hoisted_3), isRangeType.value ? (openBlock(), createElementBlock("input", {
+						key: 0,
+						type: "hidden",
+						name: endFieldName.value,
+						value: serialized(asRange(modelValue.value)?.end)
+					}, null, 8, _hoisted_4)) : createCommentVNode("", true)], 64)) : createCommentVNode("", true)
+				]), createVNode(unref(GPopoverContent_default), {
+					align: __props.align,
+					class: normalizeClass(unref(cn)("w-auto p-0", __props.contentClass))
+				}, {
+					default: withCtx(() => [createElementVNode("div", _hoisted_5, [presets.value.length ? (openBlock(), createElementBlock("div", _hoisted_6, [(openBlock(true), createElementBlock(Fragment, null, renderList(presets.value, (preset) => {
+						return openBlock(), createBlock(unref(GButton_default), {
+							key: preset.label,
+							type: "button",
+							variant: "ghost-primary",
+							size: "sm",
+							disabled: __props.disabled,
+							"data-active": active.value === preset,
+							class: "data-[active=true]:bg-accent data-[active=true]:text-accent-foreground shrink-0 justify-start font-normal",
+							onClick: ($event) => applyPreset(preset)
+						}, {
+							default: withCtx(() => [createTextVNode(toDisplayString(preset.label), 1)]),
+							_: 2
+						}, 1032, [
+							"disabled",
+							"data-active",
+							"onClick"
+						]);
+					}), 128))])) : createCommentVNode("", true), isRangeType.value ? (openBlock(), createBlock(unref(GRangeCalendar_default), mergeProps({ key: 1 }, {
+						..._ctx.$attrs,
+						...calendarProps.value
+					}, {
+						"model-value": range.value,
+						placeholder: monthOnScreen.value,
+						locale: __props.locale,
+						disabled: __props.disabled,
+						"initial-focus": "",
+						"onUpdate:modelValue": handleRange,
+						"onUpdate:placeholder": handleMonthChange
+					}), null, 16, [
+						"model-value",
+						"placeholder",
+						"locale",
+						"disabled"
+					])) : (openBlock(), createBlock(unref(GCalendar_default), mergeProps({ key: 2 }, {
+						..._ctx.$attrs,
+						...calendarProps.value
+					}, {
+						"model-value": single.value,
+						placeholder: monthOnScreen.value,
+						locale: __props.locale,
+						disabled: __props.disabled,
+						"initial-focus": "",
+						"onUpdate:modelValue": handleSingle,
+						"onUpdate:placeholder": handleMonthChange
+					}), null, 16, [
+						"model-value",
+						"placeholder",
+						"locale",
+						"disabled"
+					]))]), _ctx.$slots.footer ? (openBlock(), createElementBlock("div", _hoisted_7, [renderSlot(_ctx.$slots, "footer", {
+						value: modelValue.value,
+						clear,
+						close
+					})])) : createCommentVNode("", true)]),
+					_: 3
+				}, 8, ["align", "class"])]),
+				_: 3
+			}, 8, ["open"]);
+		};
+	}
+});
+export { DatePicker_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/gandalf/kit/date-picker/date.d.ts

@@ -0,0 +1,44 @@
+import { DateValue } from '@internationalized/date';
+import { DatePickerDate, DatePickerMatcher, DatePickerRange } from './types';
+/** Whether a model value is a range rather than a single day. */
+export declare function isRange(value: unknown): value is DatePickerRange;
+/**
+ * Reads whatever the caller put in `v-model` as a calendar date — a day, with no time and no
+ * timezone, which is what a date on a form actually is.
+ *
+ * A string is parsed with `parseDate` rather than `new Date(value)`. The built-in parser reads a
+ * bare `'2026-09-03'` as UTC midnight, which in Bogotá (UTC-5) is the evening of the 2nd: the
+ * picker would highlight the day before the one the API sent. `parseDate` has no timezone at all.
+ *
+ * A `Date` is read through its local fields, because the day the user picked is the day they saw
+ * on their own screen, not the one the same instant lands on in UTC.
+ *
+ * Anything unparseable comes back as `undefined` — an invalid date is the same as no date here,
+ * and throwing would take a whole form down over one bad field.
+ */
+export declare function toCalendarDate(value: DatePickerDate | undefined | null): DateValue | undefined;
+/** A calendar date back as a native `Date`, at local midnight. */
+export declare function toNativeDate(value: DateValue): Date;
+export declare function toNativeDate(value: DateValue | undefined): Date | undefined;
+/**
+ * The `YYYY-MM-DD` form, for the wire.
+ *
+ * Built from the calendar fields rather than `toISOString()`, which converts to UTC before it
+ * reads the date off. In Bogotá (UTC-5) that is harmless for a value at local midnight, but a
+ * `Date` carrying an evening time reports tomorrow — `new Date()` after 7pm is exactly that — and
+ * east of Greenwich it is a day early even at midnight. The day someone picked should not depend
+ * on the hour they picked it.
+ */
+export declare function toISODate(value: DatePickerDate | undefined | null): string;
+/** How a picked day reads. Exported so a table can show the same string as the trigger. */
+export declare function formatDate(value: DatePickerDate | undefined | null, locale: string, options: Intl.DateTimeFormatOptions): string;
+/**
+ * How a picked range reads.
+ *
+ * `formatRange` rather than two `format` calls joined by a dash: it collapses whatever the two
+ * ends share, so a range inside one month reads `5–9 de enero de 2026` and not
+ * `5 de enero de 2026 – 9 de enero de 2026`, with the separator each locale actually uses.
+ */
+export declare function formatDateRange(range: DatePickerRange | undefined | null, locale: string, options: Intl.DateTimeFormatOptions): string;
+/** Lifts a matcher written in native `Date` terms into the one the calendar primitive expects. */
+export declare function toDateMatcher(matcher: DatePickerMatcher | undefined): ((date: DateValue) => boolean) | undefined;

package/dist/components/gandalf/kit/date-picker/date.js

@@ -0,0 +1,89 @@
+import { CalendarDate, getLocalTimeZone, parseDate } from "@internationalized/date";
+// src/components/gandalf/kit/date-picker/date.ts
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+/** Whether a model value is a range rather than a single day. */
+function isRange(value) {
+	return typeof value === "object" && value !== null && !(value instanceof Date) && ("start" in value || "end" in value);
+}
+/**
+* Reads whatever the caller put in `v-model` as a calendar date — a day, with no time and no
+* timezone, which is what a date on a form actually is.
+*
+* A string is parsed with `parseDate` rather than `new Date(value)`. The built-in parser reads a
+* bare `'2026-09-03'` as UTC midnight, which in Bogotá (UTC-5) is the evening of the 2nd: the
+* picker would highlight the day before the one the API sent. `parseDate` has no timezone at all.
+*
+* A `Date` is read through its local fields, because the day the user picked is the day they saw
+* on their own screen, not the one the same instant lands on in UTC.
+*
+* Anything unparseable comes back as `undefined` — an invalid date is the same as no date here,
+* and throwing would take a whole form down over one bad field.
+*/
+function toCalendarDate(value) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "string") {
+		const day = value.slice(0, 10);
+		if (!ISO_DATE.test(day)) return void 0;
+		try {
+			return parseDate(day);
+		} catch {
+			return;
+		}
+	}
+	if (Number.isNaN(value.getTime())) return void 0;
+	return new CalendarDate(value.getFullYear(), value.getMonth() + 1, value.getDate());
+}
+function toNativeDate(value) {
+	return value?.toDate(getLocalTimeZone());
+}
+/**
+* The `YYYY-MM-DD` form, for the wire.
+*
+* Built from the calendar fields rather than `toISOString()`, which converts to UTC before it
+* reads the date off. In Bogotá (UTC-5) that is harmless for a value at local midnight, but a
+* `Date` carrying an evening time reports tomorrow — `new Date()` after 7pm is exactly that — and
+* east of Greenwich it is a day early even at midnight. The day someone picked should not depend
+* on the hour they picked it.
+*/
+function toISODate(value) {
+	const date = toCalendarDate(value);
+	if (!date) return "";
+	const month = String(date.month).padStart(2, "0");
+	const day = String(date.day).padStart(2, "0");
+	return `${String(date.year).padStart(4, "0")}-${month}-${day}`;
+}
+/**
+* A day as the instant `Intl` should be handed, which is local **noon**.
+*
+* Not midnight: midnight is the one hour a DST jump can delete. Where a timezone springs forward
+* at 00:00 — Santiago, Havana and Beirut all do — that day has no midnight, the conversion lands
+* on a neighbouring instant, and the trigger prints a day the user did not pick. No jump has ever
+* moved noon.
+*/
+function atNoon(value) {
+	return new Date(value.year, value.month - 1, value.day, 12);
+}
+/** How a picked day reads. Exported so a table can show the same string as the trigger. */
+function formatDate(value, locale, options) {
+	const date = toCalendarDate(value);
+	return date ? new Intl.DateTimeFormat(locale, options).format(atNoon(date)) : "";
+}
+/**
+* How a picked range reads.
+*
+* `formatRange` rather than two `format` calls joined by a dash: it collapses whatever the two
+* ends share, so a range inside one month reads `5–9 de enero de 2026` and not
+* `5 de enero de 2026 – 9 de enero de 2026`, with the separator each locale actually uses.
+*/
+function formatDateRange(range, locale, options) {
+	const start = toCalendarDate(range?.start);
+	const end = toCalendarDate(range?.end);
+	if (!start) return "";
+	if (!end) return formatDate(range?.start, locale, options);
+	return new Intl.DateTimeFormat(locale, options).formatRange(atNoon(start), atNoon(end));
+}
+/** Lifts a matcher written in native `Date` terms into the one the calendar primitive expects. */
+function toDateMatcher(matcher) {
+	return matcher ? (date) => matcher(toNativeDate(date)) : void 0;
+}
+export { formatDate, formatDateRange, isRange, toCalendarDate, toDateMatcher, toISODate, toNativeDate };

package/dist/components/gandalf/kit/date-picker/index.d.ts

@@ -0,0 +1,4 @@
+export { default as GKitDatePicker } from './DatePicker.vue';
+export { formatDate, formatDateRange, isRange, toCalendarDate, toDateMatcher, toISODate, toNativeDate, } from './date';
+export { activePreset, resolvePreset } from './presets';
+export type { DatePickerDate, DatePickerMatcher, DatePickerModelValue, DatePickerPreset, DatePickerRange, DatePickerSelection, DatePickerType, DatePickerWeekStart, } from './types';

package/dist/components/gandalf/kit/date-picker/presets.d.ts

@@ -0,0 +1,11 @@
+import { DatePickerModelValue, DatePickerPreset } from './types';
+/** A preset's selection as of now. */
+export declare function resolvePreset(preset: DatePickerPreset): DatePickerModelValue;
+/**
+ * Which preset the current selection stands for, if any.
+ *
+ * Compared by day rather than by identity: a preset given as a function hands back a fresh date on
+ * every call, so `===` is always false and the row would never highlight. Exported on its own for
+ * a preset row rendered outside the picker.
+ */
+export declare function activePreset(presets: DatePickerPreset[], value: DatePickerModelValue): DatePickerPreset | undefined;

package/dist/components/gandalf/kit/date-picker/presets.js

@@ -0,0 +1,29 @@
+import { isRange, toISODate } from "./date.js";
+// src/components/gandalf/kit/date-picker/presets.ts
+/** A preset's selection as of now. */
+function resolvePreset(preset) {
+	return typeof preset.value === "function" ? preset.value() : preset.value;
+}
+/** The day fields of a selection, and nothing else — what two selections are compared by. */
+function key(value) {
+	if (value === void 0 || value === null) return "";
+	if (isRange(value)) {
+		const start = toISODate(value.start);
+		const end = toISODate(value.end);
+		return start || end ? `${start}/${end}` : "";
+	}
+	return toISODate(value);
+}
+/**
+* Which preset the current selection stands for, if any.
+*
+* Compared by day rather than by identity: a preset given as a function hands back a fresh date on
+* every call, so `===` is always false and the row would never highlight. Exported on its own for
+* a preset row rendered outside the picker.
+*/
+function activePreset(presets, value) {
+	const target = key(value);
+	if (target === "") return void 0;
+	return presets.find((preset) => key(resolvePreset(preset)) === target);
+}
+export { activePreset, resolvePreset };

package/dist/components/gandalf/kit/date-picker/types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A day, in the shapes a caller is likely to already have one in.
+ *
+ * A `string` is read as an ISO date (`YYYY-MM-DD`) — the shape the platform's APIs speak — so a
+ * value straight off a response can be bound without converting it first. What the picker writes
+ * back is always a `Date`, so a caller only ever has to read one type.
+ */
+export type DatePickerDate = Date | string;
+/** A range. `end` is missing for as long as it takes the user to click the second day. */
+export type DatePickerRange = {
+    start?: DatePickerDate;
+    end?: DatePickerDate;
+};
+/** What `v-model` carries: a day for `type="single"`, a range for `type="range"`. */
+export type DatePickerModelValue = DatePickerDate | DatePickerRange | undefined;
+/** What the picker writes back: the same two shapes, narrowed to `Date`. */
+export type DatePickerSelection = Date | {
+    start?: Date;
+    end?: Date;
+} | undefined;
+/** Whether `value` is a day or a range. */
+export type DatePickerType = 'single' | 'range';
+/** Keeps a single day out of reach. Return `true` to disable it. */
+export type DatePickerMatcher = (date: Date) => boolean;
+/** The first column of the week. `0` is Sunday, `1` Monday. */
+export type DatePickerWeekStart = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * A shortcut beside the calendar.
+ *
+ * Give `value` as a function whenever it is relative to now. A preset computed once at module
+ * scope is right until midnight and then quietly wrong for everyone who left the tab open; the
+ * function is called when the row renders and again when it is clicked, so both the highlight and
+ * the selection come from the clock as it is.
+ */
+export type DatePickerPreset = {
+    /** Shown on the shortcut, and on the trigger while it is the active selection. */
+    label: string;
+    /** The selection it stands for. */
+    value: DatePickerModelValue | (() => DatePickerModelValue);
+};

package/dist/components/gandalf/kit/files-card/FilesCard.js

@@ -0,0 +1,4 @@
+import FilesCard_vue_vue_type_script_setup_true_lang_default from "./FilesCard.vue_vue_type_script_setup_true_lang.js";
+// src/components/gandalf/kit/files-card/FilesCard.vue
+var FilesCard_default = FilesCard_vue_vue_type_script_setup_true_lang_default;
+export { FilesCard_default as default };

package/dist/components/gandalf/kit/files-card/FilesCard.vue.d.ts

@@ -0,0 +1,44 @@
+import { HTMLAttributes } from 'vue';
+import { GandalfFilesCardType } from './index';
+type __VLS_Props = {
+    title: string;
+    type?: GandalfFilesCardType;
+    /** Second line of a folder, e.g. "12 files". */
+    fileCount?: string | number;
+    /** File type shown in the preview of a file, e.g. "xlsx". */
+    extension?: string;
+    /** Activated state ("State=Activated" in Figma). */
+    modelValue?: boolean;
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {}, __VLS_8: {}, __VLS_10: {}, __VLS_12: {}, __VLS_14: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_1) => any;
+} & {
+    actions?: (props: typeof __VLS_8) => any;
+} & {
+    icon?: (props: typeof __VLS_10) => any;
+} & {
+    actions?: (props: typeof __VLS_12) => any;
+} & {
+    preview?: (props: typeof __VLS_14) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    type: GandalfFilesCardType;
+    modelValue: boolean;
+    class: string | false | Record<string, any> | import('vue').ClassValue[] | null;
+    fileCount: string | number;
+    extension: string;
+}, {}, {}, {}, 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;
+    };
+};