ropav 0.0.8 → 0.0.9

package/dist/color-picker2.js

@@ -0,0 +1,18 @@
+//#region src/components/color-picker/types.ts
+var colorPickerFormats = [
+	"hex",
+	"hexa",
+	"rgb",
+	"rgba",
+	"hsl",
+	"hsla"
+];
+var colorPickerSizes = [
+	"xs",
+	"sm",
+	"md",
+	"lg",
+	"xl"
+];
+//#endregion
+export { colorPickerSizes as n, colorPickerFormats as t };

package/dist/color-swatch.css

@@ -0,0 +1,50 @@
+.rp-color-swatch[data-v-b0899989] {
+  --_rp-color-swatch-size: 24px;
+  --_rp-color-swatch-radius: var(--rp-radius-sm);
+  --_rp-color-swatch-checkerboard-tile: var(--rp-color-gray-3);
+  --_rp-color-swatch-checkerboard-tile-alt: var(--rp-color-white);
+  --_rp-color-swatch-checkerboard: conic-gradient(
+      var(--_rp-color-swatch-checkerboard-tile) 25%,
+      var(--_rp-color-swatch-checkerboard-tile-alt) 0 50%,
+      var(--_rp-color-swatch-checkerboard-tile) 0 75%,
+      var(--_rp-color-swatch-checkerboard-tile-alt) 0
+  );
+  --_rp-color-swatch-checkerboard-size: calc(var(--_rp-color-swatch-size) / 2)
+      calc(var(--_rp-color-swatch-size) / 2);
+  --_rp-color-swatch-overlay-stroke: rgb(0 0 0 / 10%);
+  --_rp-color-swatch-overlay-shadow: rgb(0 0 0 / 15%);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  width: var(--_rp-color-swatch-size);
+  height: var(--_rp-color-swatch-size);
+  flex-shrink: 0;
+  background: linear-gradient(var(--_rp-color-swatch-color), var(--_rp-color-swatch-color)), var(--_rp-color-swatch-checkerboard);
+  background-size: auto, var(--_rp-color-swatch-checkerboard-size);
+  border: 0;
+  border-radius: var(--_rp-color-swatch-radius);
+  box-shadow: var(--_rp-color-swatch-overlay-stroke) 0 0 0 0.0625rem inset, var(--_rp-color-swatch-overlay-shadow) 0 0 0.25rem inset;
+  color: var(--_rp-color-swatch-fg);
+  line-height: 1;
+  overflow: hidden;
+  vertical-align: middle;
+}
+html.dark .rp-color-swatch[data-v-b0899989], [data-rp-color-scheme=dark] .rp-color-swatch[data-v-b0899989] {
+  --_rp-color-swatch-checkerboard-tile: var(--rp-color-dark-6);
+  --_rp-color-swatch-checkerboard-tile-alt: var(--rp-color-dark-4);
+}
+.rp-color-swatch__icon[data-v-b0899989] {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 70%;
+  height: 70%;
+  color: inherit;
+  pointer-events: none;
+}
+.rp-color-swatch__icon[data-v-b0899989] svg {
+  display: block;
+  width: 100%;
+  height: 100%;
+}

package/dist/color-swatch.js

@@ -0,0 +1,73 @@
+import './color-swatch.css';
+import { t as parseCssColor } from "./color.js";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
+import { child, computed, createSlot, defineVaporComponent, renderEffect, setDynamicProps, setInsertionState, template, unref, useAttrs } from "vue";
+//#region src/components/color-swatch/useColorSwatchColor.ts
+function getColorSwatchForeground(color) {
+	const background = parseCssColor(color);
+	if (!background) return "var(--rp-color-white)";
+	return getPerceivedBrightness(background) >= 186 ? "var(--rp-color-black)" : "var(--rp-color-white)";
+}
+function getColorSwatchOverlay(color) {
+	const background = parseCssColor(color);
+	if (!background || getPerceivedBrightness(background) >= 80) return {
+		stroke: "rgb(0 0 0 / 10%)",
+		shadow: "rgb(0 0 0 / 15%)"
+	};
+	return {
+		stroke: "rgb(255 255 255 / 18%)",
+		shadow: "rgb(255 255 255 / 10%)"
+	};
+}
+function getPerceivedBrightness({ red, green, blue }) {
+	return (red * 299 + green * 587 + blue * 114) / 1e3;
+}
+//#endregion
+//#region src/components/color-swatch/color-swatch.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<span data-v-b0899989><span data-v-b0899989 class=rp-color-swatch__icon aria-hidden=true>", 1);
+//#endregion
+//#region src/components/color-swatch/color-swatch.vue
+var color_swatch_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
+	name: "RpColorSwatch",
+	inheritAttrs: false,
+	__name: "color-swatch",
+	props: {
+		color: {},
+		size: {},
+		ariaLabel: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const attrs = useAttrs();
+		const isHidden = computed(() => attrs["aria-hidden"] === true || attrs["aria-hidden"] === "true");
+		const rootRole = computed(() => isHidden.value ? void 0 : "img");
+		const rootAriaLabel = computed(() => isHidden.value ? void 0 : props.ariaLabel || `Color swatch ${props.color}`);
+		const rootStyle = computed(() => {
+			const overlay = getColorSwatchOverlay(props.color);
+			const style = {
+				"--_rp-color-swatch-color": props.color,
+				"--_rp-color-swatch-fg": getColorSwatchForeground(props.color),
+				"--_rp-color-swatch-overlay-stroke": overlay.stroke,
+				"--_rp-color-swatch-overlay-shadow": overlay.shadow
+			};
+			if (props.size !== void 0) style["--_rp-color-swatch-size"] = normalizeSize(props.size);
+			return style;
+		});
+		function normalizeSize(size) {
+			return typeof size === "number" ? `${size}px` : size;
+		}
+		const n2 = t0();
+		const n1 = child(n2);
+		renderEffect(() => setDynamicProps(n2, [unref(attrs), {
+			class: "rp-color-swatch",
+			style: rootStyle.value,
+			role: rootRole.value,
+			"aria-label": rootAriaLabel.value
+		}]));
+		setInsertionState(n1, null, 0);
+		createSlot("default", null, null, 1);
+		return n2;
+	}
+}), [["__scopeId", "data-v-b0899989"]]);
+//#endregion
+export { color_swatch_default as t };

package/dist/color.js

@@ -0,0 +1,190 @@
+//#region src/utils/color.ts
+var DEFAULT_OPACITY = 100;
+var NUMBER_SOURCE = String.raw`[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?`;
+var NUMBER_PATTERN = new RegExp(`^${NUMBER_SOURCE}$`, "i");
+var HUE_PATTERN = new RegExp(`^(${NUMBER_SOURCE})(deg|grad|rad|turn)?$`, "i");
+function parseCssColor(value) {
+	const color = value.trim().toLowerCase();
+	if (color === "black") return {
+		red: 0,
+		green: 0,
+		blue: 0,
+		opacity: DEFAULT_OPACITY
+	};
+	if (color === "white") return {
+		red: 255,
+		green: 255,
+		blue: 255,
+		opacity: DEFAULT_OPACITY
+	};
+	if (color === "transparent") return {
+		red: 0,
+		green: 0,
+		blue: 0,
+		opacity: 0
+	};
+	return parseHexColor(color) ?? parseRgbColor(color) ?? parseHslColor(color);
+}
+function parseHexColor(color) {
+	const hex = color.match(/^#([\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i)?.[1];
+	if (!hex) return void 0;
+	if (hex.length === 3 || hex.length === 4) return {
+		red: Number.parseInt(hex[0] + hex[0], 16),
+		green: Number.parseInt(hex[1] + hex[1], 16),
+		blue: Number.parseInt(hex[2] + hex[2], 16),
+		opacity: hex.length === 4 ? roundPercent(Number.parseInt(hex[3] + hex[3], 16) / 255 * 100) : DEFAULT_OPACITY
+	};
+	return {
+		red: Number.parseInt(hex.slice(0, 2), 16),
+		green: Number.parseInt(hex.slice(2, 4), 16),
+		blue: Number.parseInt(hex.slice(4, 6), 16),
+		opacity: hex.length === 8 ? roundPercent(Number.parseInt(hex.slice(6, 8), 16) / 255 * 100) : DEFAULT_OPACITY
+	};
+}
+function parseRgbColor(color) {
+	const body = color.match(/^rgba?\((.*)\)$/i)?.[1];
+	if (body == null) return void 0;
+	const parsed = parseFunctionChannels(body);
+	if (!parsed) return void 0;
+	if (parsed.legacy) {
+		const percentageChannels = parsed.channels.filter((channel) => channel.endsWith("%"));
+		if (percentageChannels.length !== 0 && percentageChannels.length !== parsed.channels.length) return;
+	}
+	const [red, green, blue] = parsed.channels.map(parseRgbChannel);
+	const opacity = parseAlpha(parsed.alpha);
+	if (red == null || green == null || blue == null || opacity == null) return void 0;
+	return {
+		red,
+		green,
+		blue,
+		opacity
+	};
+}
+function parseHslColor(color) {
+	const body = color.match(/^hsla?\((.*)\)$/i)?.[1];
+	if (body == null) return void 0;
+	const parsed = parseFunctionChannels(body);
+	if (!parsed) return void 0;
+	const hue = parseHue(parsed.channels[0]);
+	const saturation = parsePercentage(parsed.channels[1]);
+	const lightness = parsePercentage(parsed.channels[2]);
+	const opacity = parseAlpha(parsed.alpha);
+	if (hue == null || saturation == null || lightness == null || opacity == null) return;
+	return hslToRgb(hue, saturation, lightness, opacity);
+}
+function parseFunctionChannels(body) {
+	const value = body.trim();
+	if (!value) return void 0;
+	if (value.includes(",")) {
+		if (value.includes("/")) return void 0;
+		const parts = value.split(",").map((part) => part.trim());
+		if (parts.length !== 3 && parts.length !== 4 || parts.some((part) => !part)) return;
+		return {
+			channels: [
+				parts[0],
+				parts[1],
+				parts[2]
+			],
+			alpha: parts[3],
+			legacy: true
+		};
+	}
+	const slashParts = value.split("/");
+	if (slashParts.length > 2) return void 0;
+	const channels = slashParts[0].trim().split(/\s+/).filter(Boolean);
+	const alpha = slashParts[1]?.trim();
+	if (channels.length !== 3 || slashParts.length === 2 && !alpha) return void 0;
+	return {
+		channels: [
+			channels[0],
+			channels[1],
+			channels[2]
+		],
+		alpha,
+		legacy: false
+	};
+}
+function parseRgbChannel(channel) {
+	const percentage = parsePercentage(channel);
+	if (percentage != null) return clamp(Math.round(percentage / 100 * 255), 0, 255);
+	const number = parseNumber(channel);
+	return number == null ? void 0 : clamp(Math.round(number), 0, 255);
+}
+function parseHue(channel) {
+	const match = channel.trim().match(HUE_PATTERN);
+	if (!match) return void 0;
+	const value = Number(match[1]);
+	if (!Number.isFinite(value)) return void 0;
+	switch (match[2]) {
+		case "grad": return value * .9;
+		case "rad": return value * 180 / Math.PI;
+		case "turn": return value * 360;
+		default: return value;
+	}
+}
+function parsePercentage(channel) {
+	const value = channel.trim();
+	if (!value.endsWith("%")) return void 0;
+	const number = parseNumber(value.slice(0, -1));
+	return number == null ? void 0 : clamp(number, 0, 100);
+}
+function parseAlpha(alpha) {
+	if (alpha === void 0) return DEFAULT_OPACITY;
+	const percentage = parsePercentage(alpha);
+	if (percentage != null) return roundPercent(percentage);
+	const number = parseNumber(alpha);
+	return number == null ? void 0 : roundPercent(clamp(number, 0, 1) * 100);
+}
+function parseNumber(value) {
+	const token = value.trim();
+	if (!NUMBER_PATTERN.test(token)) return void 0;
+	const number = Number(token);
+	return Number.isFinite(number) ? number : void 0;
+}
+function hslToRgb(hue, saturation, lightness, opacity) {
+	const h = normalizeHue(hue);
+	const s = clamp(saturation, 0, 100) / 100;
+	const l = clamp(lightness, 0, 100) / 100;
+	const c = (1 - Math.abs(2 * l - 1)) * s;
+	const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+	const m = l - c / 2;
+	let red = 0;
+	let green = 0;
+	let blue = 0;
+	if (h < 60) {
+		red = c;
+		green = x;
+	} else if (h < 120) {
+		red = x;
+		green = c;
+	} else if (h < 180) {
+		green = c;
+		blue = x;
+	} else if (h < 240) {
+		green = x;
+		blue = c;
+	} else if (h < 300) {
+		red = x;
+		blue = c;
+	} else {
+		red = c;
+		blue = x;
+	}
+	return {
+		red: Math.round((red + m) * 255),
+		green: Math.round((green + m) * 255),
+		blue: Math.round((blue + m) * 255),
+		opacity
+	};
+}
+function normalizeHue(value) {
+	return (value % 360 + 360) % 360;
+}
+function roundPercent(value) {
+	return Math.round(value * 100) / 100;
+}
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+//#endregion
+export { parseCssColor as t };

package/dist/componentColors.js

@@ -1,20 +1,213 @@
+import { t as parseCssColor } from "./color.js";
 //#region src/utils/componentColors.ts
 var componentColors = [
-	"primary",
-	"secondary",
-	"success",
-	"warning",
-	"danger",
-	"info",
-	"neutral"
+	"dark",
+	"gray",
+	"red",
+	"pink",
+	"grape",
+	"violet",
+	"indigo",
+	"blue",
+	"cyan",
+	"teal",
+	"green",
+	"lime",
+	"yellow",
+	"orange"
+];
+var componentColorShades = [
+	"0",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9"
 ];
 var componentColorNames = new Set(componentColors);
-function isComponentPresetColor(color) {
-	return Boolean(color && componentColorNames.has(color));
+var componentColorShadeNames = new Set(componentColorShades);
+function parseComponentColor(color) {
+	if (!color) return { kind: "empty" };
+	if (color === "primary") return { kind: "primary" };
+	if (componentColorNames.has(color)) return {
+		kind: "preset",
+		color
+	};
+	const shadeMatch = color.match(/^([a-z]+)\.(\d+)$/);
+	if (shadeMatch && componentColorNames.has(shadeMatch[1])) return componentColorShadeNames.has(shadeMatch[2]) ? {
+		kind: "shade",
+		color: shadeMatch[1],
+		shade: shadeMatch[2]
+	} : {
+		kind: "invalid",
+		value: color
+	};
+	return {
+		kind: "custom",
+		value: color
+	};
+}
+function getComponentColorValue(color) {
+	const parsed = parseComponentColor(color);
+	if (parsed.kind === "primary") return "var(--rp-primary-color-filled)";
+	if (parsed.kind === "preset") return `var(--rp-color-${parsed.color}-filled)`;
+	if (parsed.kind === "shade") return `var(--rp-color-${parsed.color}-${parsed.shade})`;
+	if (parsed.kind === "custom") return parsed.value;
+}
+function getComponentContrastColor(color, options = {}) {
+	if (!options.autoContrast) return "var(--rp-color-white)";
+	const parsed = parseComponentColor(color);
+	if (parsed.kind === "primary") return "var(--rp-primary-color-contrast)";
+	if (parsed.kind === "preset") return `var(--rp-color-${parsed.color}-contrast)`;
+	if (parsed.kind === "shade") return `var(--rp-color-${parsed.color}-${parsed.shade}-contrast)`;
+	if (parsed.kind === "custom") return getReadableColorVariable(parsed.value);
+	return "var(--rp-color-white)";
+}
+function getComponentColorRoles(color) {
+	const parsed = parseComponentColor(color);
+	if (parsed.kind === "empty" || parsed.kind === "invalid") return;
+	if (parsed.kind === "primary") return createComponentColorRoles("var(--rp-primary-color-filled)", {
+		hover: "var(--rp-primary-color-filled-hover)",
+		contrast: "var(--rp-primary-color-contrast)",
+		light: "var(--rp-primary-color-light)",
+		lightHover: "var(--rp-primary-color-light-hover)",
+		outline: "var(--rp-primary-color-outline)",
+		outlineHover: "color-mix(in srgb, var(--rp-primary-color-outline) 62%, transparent)",
+		foreground: "var(--rp-primary-color-light-color)"
+	});
+	if (parsed.kind === "preset") return createComponentColorRoles(`var(--rp-color-${parsed.color}-filled)`, {
+		hover: `var(--rp-color-${parsed.color}-filled-hover)`,
+		contrast: `var(--rp-color-${parsed.color}-contrast)`,
+		light: `var(--rp-color-${parsed.color}-light)`,
+		lightHover: `var(--rp-color-${parsed.color}-light-hover)`,
+		outline: `var(--rp-color-${parsed.color}-outline)`,
+		outlineHover: `color-mix(in srgb, var(--rp-color-${parsed.color}-outline) 62%, transparent)`,
+		foreground: `var(--rp-color-${parsed.color}-light-color)`
+	});
+	if (parsed.kind === "shade") {
+		const base = `var(--rp-color-${parsed.color}-${parsed.shade})`;
+		return createComponentColorRoles(base, {
+			hover: `var(--rp-color-${parsed.color}-${Math.min(Number(parsed.shade) + 1, 9)})`,
+			contrast: `var(--rp-color-${parsed.color}-${parsed.shade}-contrast)`,
+			foreground: base
+		});
+	}
+	return createComponentColorRoles(parsed.value, { contrast: getReadableColorVariable(parsed.value) });
+}
+function getComponentVariantColorRoles({ color, variant, defaultColor = "primary", autoContrast }) {
+	const roles = getComponentColorRoles(color ?? defaultColor);
+	if (!roles) return void 0;
+	const contrast = getComponentContrastColor(color ?? defaultColor, { autoContrast });
+	if (variant === "solid") return {
+		background: roles.filled,
+		hover: roles.hover,
+		active: roles.active,
+		color: contrast,
+		border: roles.filled,
+		borderHover: roles.hover,
+		borderActive: roles.active
+	};
+	if (variant === "subtle") return {
+		background: roles.light,
+		hover: roles.lightHover,
+		active: roles.lightActive,
+		color: roles.foreground,
+		border: "transparent",
+		borderHover: "transparent",
+		borderActive: "transparent"
+	};
+	if (variant === "surface") return {
+		background: roles.light,
+		hover: roles.lightHover,
+		active: roles.lightActive,
+		color: roles.foreground,
+		border: roles.outline,
+		borderHover: roles.lightHover,
+		borderActive: roles.outlineHover
+	};
+	if (variant === "outline") return {
+		background: "transparent",
+		hover: roles.lightHover,
+		active: roles.lightActive,
+		color: roles.foreground,
+		border: roles.outline,
+		borderHover: roles.outlineHover,
+		borderActive: roles.outlineHover
+	};
+	if (variant === "ghost") return {
+		background: "transparent",
+		hover: roles.lightHover,
+		active: roles.lightActive,
+		color: roles.foreground,
+		border: "transparent",
+		borderHover: "transparent",
+		borderActive: "transparent"
+	};
+	if (variant === "plain") return {
+		background: "transparent",
+		hover: "transparent",
+		active: "transparent",
+		color: roles.foreground,
+		border: "transparent",
+		borderHover: "transparent",
+		borderActive: "transparent"
+	};
+	return {
+		background: "var(--rp-color-default)",
+		hover: roles.lightHover,
+		active: roles.lightActive,
+		color: roles.foreground,
+		border: roles.outline,
+		borderHover: roles.outlineHover,
+		borderActive: roles.outlineHover
+	};
+}
+function createComponentColorRoles(color, overrides = {}) {
+	return {
+		filled: color,
+		hover: `color-mix(in srgb, ${color} 90%, var(--rp-color-black))`,
+		active: `color-mix(in srgb, ${color} 80%, var(--rp-color-black))`,
+		contrast: "var(--rp-color-white)",
+		light: `color-mix(in srgb, ${color} 12%, transparent)`,
+		lightHover: `color-mix(in srgb, ${color} 18%, transparent)`,
+		lightActive: `color-mix(in srgb, ${color} 24%, transparent)`,
+		outline: color,
+		outlineHover: `color-mix(in srgb, ${color} 62%, transparent)`,
+		foreground: color,
+		...overrides
+	};
+}
+function getReadableColorVariable(color) {
+	const parsed = parseCssColor(color);
+	if (!parsed) return "var(--rp-color-white)";
+	return contrastRatio({
+		red: 0,
+		green: 0,
+		blue: 0
+	}, parsed) >= contrastRatio({
+		red: 255,
+		green: 255,
+		blue: 255
+	}, parsed) ? "var(--rp-color-black)" : "var(--rp-color-white)";
+}
+function contrastRatio(foreground, background) {
+	const foregroundLuminance = relativeLuminance(foreground);
+	const backgroundLuminance = relativeLuminance(background);
+	const lighter = Math.max(foregroundLuminance, backgroundLuminance);
+	const darker = Math.min(foregroundLuminance, backgroundLuminance);
+	return (lighter + .05) / (darker + .05);
 }
-function getComponentCustomColor(color) {
-	if (!color || isComponentPresetColor(color)) return void 0;
-	return color;
+function relativeLuminance(color) {
+	const [red, green, blue] = [
+		color.red,
+		color.green,
+		color.blue
+	].map((channel) => channel / 255).map((channel) => channel <= .03928 ? channel / 12.92 : ((channel + .055) / 1.055) ** 2.4);
+	return .2126 * red + .7152 * green + .0722 * blue;
 }
 //#endregion
-export { getComponentCustomColor as n, isComponentPresetColor as r, componentColors as t };
+export { getComponentVariantColorRoles as i, getComponentColorValue as n, getComponentContrastColor as r, componentColors as t };

package/dist/components/alert/alert.d.ts

@@ -0,0 +1,30 @@
+import { AlertProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AlertProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        onClose?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        icon?: (props: {}) => any;
+    } & {
+        title?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        action?: (props: {}) => any;
+    };
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "close") => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/alert/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Alert } from './alert';
+export { alertColors, alertRadiuses, alertVariants } from './types';
+export type { AlertColor, AlertProps, AlertRadius, AlertRole, AlertVariant } from './types';

package/dist/components/alert/index.js

@@ -0,0 +1,2 @@
+import { i as alert_default, n as alertRadiuses, r as alertVariants, t as alertColors } from "../../alert.js";
+export { alert_default as Alert, alertColors, alertRadiuses, alertVariants };

package/dist/components/alert/types.d.ts

@@ -0,0 +1,20 @@
+import { ComponentColorValue } from '../../utils/componentColors';
+export declare const alertColors: readonly ["dark", "gray", "red", "pink", "grape", "violet", "indigo", "blue", "cyan", "teal", "green", "lime", "yellow", "orange"];
+export declare const alertVariants: readonly ["subtle", "surface", "outline", "solid"];
+export declare const alertRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl"];
+export type AlertColor = ComponentColorValue;
+export type AlertVariant = (typeof alertVariants)[number];
+export type AlertRadius = (typeof alertRadiuses)[number];
+export type AlertRole = 'alert' | 'status' | 'none';
+export interface AlertProps {
+    open?: boolean;
+    title?: string;
+    description?: string;
+    variant?: AlertVariant;
+    color?: AlertColor;
+    autoContrast?: boolean;
+    radius?: AlertRadius;
+    role?: AlertRole;
+    closable?: boolean;
+    closeLabel?: string;
+}

package/dist/components/alert/useAlertColor.d.ts

@@ -0,0 +1,3 @@
+import { CSSProperties } from 'vue';
+import { AlertColor, AlertVariant } from './types';
+export declare function getAlertColorStyle(color: AlertColor | undefined, variant: AlertVariant | undefined, autoContrast: boolean | undefined): CSSProperties | undefined;

package/dist/components/aspect-ratio/aspect-ratio.d.ts

@@ -0,0 +1,21 @@
+import { AspectRatioProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AspectRatioProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/aspect-ratio/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AspectRatio } from './aspect-ratio';
+export type { AspectRatioProps } from './types';

package/dist/components/aspect-ratio/index.js

@@ -0,0 +1,2 @@
+import { t as aspect_ratio_default } from "../../aspect-ratio.js";
+export { aspect_ratio_default as AspectRatio };

package/dist/components/aspect-ratio/types.d.ts

@@ -0,0 +1,3 @@
+export interface AspectRatioProps {
+    ratio?: number;
+}