@cnamts/synapse 1.0.1 → 1.0.3

package/src/utils/amelipro/dateHelper/tests/dateHelper.spec.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest'
+import { padTo2Digits, dateMatchFrIso, dateMatchIso, parseDate, dateToFormatFr, stringToDate, parseDateToFr, dateToBasicFormat } from '../dateHelper'
+
+describe('dateHelper', () => {
+	it('padTo2digits adds a "0" before a single number and make it a string', () => {
+		const value = 2
+		expect(padTo2Digits(value)).toEqual('02')
+	})
+
+	it('wrong value does not match the date ISO', () => {
+		const value = '20/04/1976'
+		expect(dateMatchIso(value)).toBeFalsy()
+	})
+
+	it('value matches the date FR ISO', () => {
+		const value = '20/04/1976'
+		expect(dateMatchFrIso(value)).toBeTruthy()
+	})
+
+	it('good value matches the date ISO', () => {
+		const value = '1976-04-20'
+		expect(dateMatchIso(value)).toBeTruthy()
+	})
+
+	it('transform a string into an array of [year, month, day]', () => {
+		const value = '1976-04-20'
+		expect(parseDate(value)).toEqual(['1976', '04', '20'])
+	})
+
+	it('transform a string into an array of [day, month, year]', () => {
+		const value = '20/04/1976'
+		expect(parseDateToFr(value)).toEqual(['20', '04', '1976'])
+	})
+
+	it('dateToFormatFr transform a "yyyy-mm-dd" date into a "dd/mm/yyyy" date', () => {
+		const value = '1976-04-20'
+		expect(dateToFormatFr(value)).toEqual('20/04/1976')
+	})
+
+	it('dateToFormatFr transform a "dd/mm/yyyy" date into a "yyyy-mm-dd" date', () => {
+		const value = '20/04/1976'
+		expect(dateToBasicFormat(value)).toEqual('1976-04-20')
+	})
+
+	it('stringToDate transform a string "yyyy-mm-dd" date into a object Date"', () => {
+		const value = '1976-04-20'
+		expect(stringToDate(value)).toBeInstanceOf(Date)
+	})
+})

package/src/utils/amelipro/numberHelper/numberHelper.ts

@@ -0,0 +1,20 @@
+/**
+ * Regular expression to match number format.
+ * @type {RegExp}
+ */
+const NUMBER_REGEX = /^(-)?\d*([,.]\d+)?$/i
+
+/**
+ * Checks if a given string matches the regex.
+ * @param {number | string | null | undefined} value - The value to check.
+ * @returns {boolean} True if the string matches the format, false otherwise.
+ */
+export const numberMatchRegex = (value: number | string | null | undefined): boolean => {
+	if (typeof value !== 'string' && typeof value !== 'number') {
+		return false
+	}
+	return NUMBER_REGEX.test(String(value))
+}
+
+export const parseToNumber = (value: number | string): number => Number((String(value)).replace(',', '.'))
+export const parseToFrNumberFormat = (value: number | string): string => (String(value)).replace('.', ',')

package/src/utils/amelipro/numberHelper/tests/numberHelper.spec.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest'
+import { numberMatchRegex, parseToNumber, parseToFrNumberFormat } from '../numberHelper'
+
+describe('numberHelper', () => {
+	it('wrong value does not match the number regex', () => {
+		const value = numberMatchRegex('abcd')
+		expect(value).toBeFalsy()
+	})
+
+	it('good value matches the number regex', () => {
+		const value = numberMatchRegex('325.76')
+		expect(value).toBeTruthy()
+	})
+
+	it('transform "," into "." and make it a number', () => {
+		const value = '1230,723'
+		expect(parseToNumber(value)).toEqual(1230.723)
+	})
+
+	it('transform "." into "," and make it a string', () => {
+		const value = 1230.723
+		expect(parseToFrNumberFormat(value)).toEqual('1230,723')
+	})
+})

package/src/utils/amelipro/rules/maxNumber/index.ts

@@ -0,0 +1,24 @@
+import type { ValidationResult, ValidationRule } from '@/utils/rules/types'
+import { numberMatchRegex, parseToFrNumberFormat, parseToNumber } from '../../numberHelper/numberHelper'
+import { ref } from 'vue'
+
+// On a besoin de tester si le nombre reçu est inférieur ou égal au nombre maximal autorisé
+export type Value = string
+
+export function maxNumberRule(maxNumber: string | number): ValidationRule<Value> {
+	return (value: Value): ValidationResult => {
+		if (value === '' || value === undefined || value === null) {
+			return true
+		}
+		const valueHasGoodFormat = numberMatchRegex(value)
+		const maxDateHasGoodFormat = numberMatchRegex(maxNumber)
+		const valid = ref(false)
+		if (valueHasGoodFormat && maxDateHasGoodFormat) {
+			const numberToTest = parseToNumber(value)
+			const maxNumberAsNumber = parseToNumber(maxNumber)
+			valid.value = Boolean(numberToTest <= maxNumberAsNumber)
+		}
+
+		return valid.value || `Le nombre saisi doit être inférieur ou égal à ${parseToFrNumberFormat(maxNumber)}.`
+	}
+}

package/src/utils/amelipro/rules/maxNumber/tests/maxNumber.spec.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest'
+import { maxNumberRule } from '..'
+
+describe('dateHelper', () => {
+	const limitNumber = '123'
+	const underNumber = '122,99'
+	const overNumber = '123.01'
+
+	const rule = maxNumberRule(limitNumber)
+
+	it('number over the limit returns string', () => {
+		expect(rule(overNumber)).toEqual('Le nombre saisi doit être inférieur ou égal à 123.')
+	})
+
+	it('number under the limit returns true', () => {
+		expect(rule(underNumber)).toEqual(true)
+	})
+
+	it('returns true if value is an empty string', () => {
+		expect(rule('')).toEqual(true)
+	})
+})

package/src/utils/amelipro/rules/minNumber/index.ts

@@ -0,0 +1,24 @@
+import type { ValidationResult, ValidationRule } from '@/utils/rules/types'
+import { numberMatchRegex, parseToFrNumberFormat, parseToNumber } from '../../numberHelper/numberHelper'
+import { ref } from 'vue'
+
+// On a besoin de tester si le nombre reçu est supérieur ou égal au nombre  minimal autorisé
+export type Value = string
+
+export function minNumberRule(minNumber: string | number): ValidationRule<Value> {
+	return (value: Value): ValidationResult => {
+		if (value === '' || value === undefined || value === null) {
+			return true
+		}
+		const valueHasGoodFormat = numberMatchRegex(value)
+		const minDateHasGoodFormat = numberMatchRegex(minNumber)
+		const valid = ref(false)
+		if (valueHasGoodFormat && minDateHasGoodFormat) {
+			const numberToTest = parseToNumber(value)
+			const minNumberAsNumber = parseToNumber(minNumber)
+			valid.value = Boolean(numberToTest >= minNumberAsNumber)
+		}
+
+		return valid.value || `Le nombre saisi doit être supérieur ou égal à ${parseToFrNumberFormat(minNumber)}.`
+	}
+}

package/src/utils/amelipro/rules/minNumber/tests/minNumber.spec.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest'
+import { minNumberRule } from '..'
+
+describe('dateHelper', () => {
+	const limitNumber = '123'
+	const underNumber = '122,99'
+	const overNumber = '123.01'
+
+	const rule = minNumberRule(limitNumber)
+
+	it('number under the limit returns string', () => {
+		expect(rule(underNumber)).toEqual('Le nombre saisi doit être supérieur ou égal à 123.')
+	})
+
+	it('number over the limit returns true', () => {
+		expect(rule(overNumber)).toEqual(true)
+	})
+
+	it('returns true if value is an empty string', () => {
+		expect(rule('')).toEqual(true)
+	})
+})

package/src/utils/amelipro/rules/notAfterDate/index.ts

@@ -0,0 +1,33 @@
+import type { ValidationResult, ValidationRule } from '@/utils/rules/types'
+import { dateMatchFrIso, dateMatchIso, dateToBasicFormat, dateToFormatFr, stringToDate } from '../../dateHelper/dateHelper'
+import { ref } from 'vue'
+
+// On a besoin de tester si la date reçue est inférieure ou égale à la date maximale autorisée
+export type Value = string
+
+export function notAfterDate(maxDate: string, fieldType: string): ValidationRule<Value> {
+	return (value: Value): ValidationResult => {
+		if (value === '' || value === undefined || value === null) {
+			return true
+		}
+
+		const currentValue = ref(value)
+		if (fieldType === 'text' && dateMatchFrIso(value)) {
+			currentValue.value = dateToBasicFormat(value)
+		}
+
+		const valueHasGoodFormat = dateMatchIso(currentValue.value)
+		const maxDateHasGoodFormat = dateMatchIso(maxDate)
+		let valid = false
+		if (valueHasGoodFormat && maxDateHasGoodFormat) {
+			const dateToTest = stringToDate(currentValue.value)
+			const maxDateAsDate = stringToDate(maxDate)
+
+			if (dateToTest && maxDateAsDate) {
+				valid = Boolean(dateToTest <= maxDateAsDate)
+			}
+		}
+
+		return valid || `La date saisie doit être antérieure ou égale au ${dateToFormatFr(maxDate)}.`
+	}
+}

package/src/utils/amelipro/rules/notAfterDate/tests/notAfterDate.spec.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest'
+import { notAfterDate } from '..'
+import { dateToFormatFr } from '@/utils/amelipro/dateHelper/dateHelper'
+
+describe('notAfterDate', () => {
+	const currentDate = '2025-03-05'
+	const pastDate = '2025-03-04'
+	const futureDate = '2025-03-06'
+
+	const rule = notAfterDate(currentDate, 'date')
+	const ruleTextField = notAfterDate(currentDate, 'text')
+
+	it('returns true with a past date', () => {
+		expect(rule(pastDate)).toBe(true)
+	})
+
+	it('returns an error with a future date', () => {
+		expect(typeof rule(futureDate)).toBe('string')
+	})
+
+	it('returns true if the value is falsy', () => {
+		expect(rule('')).toBe(true)
+	})
+
+	it('rule for text type returns true with a past date', () => {
+		expect(ruleTextField(dateToFormatFr(pastDate))).toBe(true)
+	})
+
+	it('rule for text type returns an error with a future date', () => {
+		expect(typeof ruleTextField(dateToFormatFr(futureDate))).toBe('string')
+	})
+})

package/src/utils/amelipro/rules/notBeforeDate/index.ts

@@ -0,0 +1,33 @@
+import type { ValidationResult, ValidationRule } from '@/utils/rules/types'
+import { dateMatchFrIso, dateMatchIso, dateToBasicFormat, dateToFormatFr, stringToDate } from '../../dateHelper/dateHelper'
+import { ref } from 'vue'
+
+// On a besoin de tester si la date reçue est supérieure ou égale à la date minimale autorisée
+export type Value = string
+
+export function notBeforeDate(minDate: string, fieldType: string): ValidationRule<Value> {
+	return (value: Value): ValidationResult => {
+		if (value === '' || value === undefined || value === null) {
+			return true
+		}
+
+		const currentValue = ref(value)
+		if (fieldType === 'text' && dateMatchFrIso(value)) {
+			currentValue.value = dateToBasicFormat(value)
+		}
+
+		const valueHasGoodFormat = dateMatchIso(currentValue.value)
+		const minDateHasGoodFormat = dateMatchIso(minDate)
+		let valid = false
+		if (valueHasGoodFormat && minDateHasGoodFormat) {
+			const dateToTest = stringToDate(currentValue.value)
+			const minDateAsDate = stringToDate(minDate)
+
+			if (dateToTest && minDateAsDate) {
+				valid = Boolean(dateToTest >= minDateAsDate)
+			}
+		}
+
+		return valid || `La date saisie doit être ultérieure ou égale au ${dateToFormatFr(minDate)}.`
+	}
+}

package/src/utils/amelipro/rules/notBeforeDate/tests/notBeforeDate.spec.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest'
+import { notBeforeDate } from '..'
+import { dateToFormatFr } from '@/utils/amelipro/dateHelper/dateHelper'
+
+describe('notAfterDate', () => {
+	const currentDate = '2025-03-05'
+	const pastDate = '2025-03-04'
+	const futureDate = '2025-03-06'
+
+	const rule = notBeforeDate(currentDate, 'date')
+	const ruleTextField = notBeforeDate(currentDate, 'text')
+
+	it('returns true with a future date', () => {
+		expect(rule(futureDate)).toBe(true)
+	})
+
+	it('returns an error with a past date', () => {
+		expect(typeof rule(pastDate)).toBe('string')
+	})
+
+	it('returns true if the value is falsy', () => {
+		expect(rule('')).toBe(true)
+	})
+
+	it('rule for text type returns true with a future date', () => {
+		expect(ruleTextField(dateToFormatFr(futureDate))).toBe(true)
+	})
+
+	it('rule for text type returns an error with a past date', () => {
+		expect(typeof ruleTextField(dateToFormatFr(pastDate))).toBe('string')
+	})
+})

package/src/utils/functions/ameliproColors/ameliproColors.ts

@@ -0,0 +1,57 @@
+import type { AmeliproColorsTypes } from './types'
+
+export const AmeliproColors: AmeliproColorsTypes = {
+	apBlack: { hexColor: '#000000' },
+	apBlue: { hexColor: '#0C419A' },
+	apBluedarken1: { hexColor: '#00749C' },
+	apBluedarken2: { hexColor: '#00516D' },
+	apBluelighten1: { hexColor: '#99DBF2' },
+	apBluelighten2: { hexColor: '#CCEDF9' },
+	apBluelighten3: { hexColor: '#E6F6FC' },
+	apBluelighten4: { hexColor: '#F3FBFE' },
+	apError: { hexColor: '#B33F2E' },
+	apGreen: { hexColor: '#56C271' },
+	apGreendarken1: { hexColor: '#459B5A' },
+	apGreendarken2: { hexColor: '#337343' },
+	apGreenlighten1: { hexColor: '#78CE8D' },
+	apGreenlighten2: { hexColor: '#DDF3F3' },
+	apGrey: { hexColor: '#545859' },
+	apGreydarken1: { hexColor: '#1A1B1B' },
+	apGreylighten1: { hexColor: '#CCCDCE' },
+	apGreylighten2: { hexColor: '#DDDEDE' },
+	apGreylighten3: { hexColor: '#EEEEEE' },
+	apGreylighten4: { hexColor: '#F3F4F4' },
+	apGreylighten5: { hexColor: '#FAFAFA' },
+	apInformations: { hexColor: '#4D547D' },
+	apParme: { hexColor: '#C8D1E6' },
+	apParmedarken1: { hexColor: '#4D547D' },
+	apPink: { hexColor: '#E83182' },
+	apPrimary: { hexColor: '#00749C' },
+	apRed: { hexColor: '#B33F2E' },
+	apReddarken1: { hexColor: '#9D3728' },
+	apReddarken2: { hexColor: '#70281C' },
+	apRedlighten1: { hexColor: '#E67261' },
+	apRedlighten2: { hexColor: '#EC9588' },
+	apRedlighten3: { hexColor: '#F9DCD7' },
+	apRedlighten4: { hexColor: '#FDF0EE' },
+	apSecondary: { hexColor: '#00516D' },
+	apSuccess: { hexColor: '#007863' },
+	apTurquoise: { hexColor: '#33BCA5' },
+	apTurquoisedarken1: { hexColor: '#007863' },
+	apTurquoisedarken2: { hexColor: '#006654' },
+	apTurquoisedarken3: { hexColor: '#005647' },
+	apTurquoiselighten1: { hexColor: '#CCEEE8' },
+	apTurquoiselighten2: { hexColor: '#E6F7F4' },
+	apWarning: { hexColor: '#906C16' },
+	apWhite: { hexColor: '#FFFFFF' },
+	apYellow: { hexColor: '#F0B323' },
+	apYellowdarken1: { hexColor: '#D8A120' },
+	apYellowdarken2: { hexColor: '#C08F1C' },
+	apYellowdarken3: { hexColor: '#A87D19' },
+	apYellowdarken4: { hexColor: '#906C16' },
+	apYellowlighten1: { hexColor: '#F3C24F' },
+	apYellowlighten2: { hexColor: '#FED66D' },
+	apYellowlighten3: { hexColor: '#F7D990' },
+	apYellowlighten4: { hexColor: '#F9E1A7' },
+	apYellowlighten5: { hexColor: '#FCF0D3' },
+}

package/src/utils/functions/ameliproColors/types.d.ts

@@ -0,0 +1,5 @@
+export interface AmeliproColorsTypes {
+	[key: string]: {
+		hexColor: string
+	}
+}

package/src/utils/functions/classToHex.ts

@@ -0,0 +1,38 @@
+import { apLightTheme } from '@/designTokens/tokens/amelipro/apLightTheme'
+import { apColorsTokens } from '@/designTokens/tokens/amelipro/apColors'
+import { AmeliproColors } from './ameliproColors/ameliproColors'
+
+const currentTheme = apLightTheme
+const ameliproColors = AmeliproColors
+const colors = apColorsTokens as unknown as Record<string, Record<string, string>>
+export function classToHex(color: string): string {
+	color.toString().trim()
+	color = color?.replace(/-./, x => x[1].toUpperCase())
+	color = color?.replace('-', ' ')
+	// eslint-disable-next-line prefer-const
+	let [colorName, colorModifier] = color.split(' ', 2) as (string | undefined)[]
+	colorModifier = colorModifier?.replace('-', '')
+	let fullColorName = ''
+	let hexColor = ''
+	if (colorName && colorName in colors) {
+		if (colorModifier && colorModifier in colors[colorName]) {
+			hexColor = colors[colorName][colorModifier]
+		}
+		else if ('base' in colors[colorName]) {
+			hexColor = colors[colorName].base
+		}
+	}
+	else if (colorName && colorName in currentTheme) {
+		hexColor = currentTheme[colorName] as string
+	}
+	else if (color && colorName) {
+		if (colorModifier === undefined) {
+			fullColorName = colorName
+		}
+		else {
+			fullColorName = colorName + colorModifier
+		}
+		hexColor = ameliproColors[fullColorName]?.hexColor
+	}
+	return hexColor
+}

package/src/utils/functions/convertToHex.ts

@@ -0,0 +1,23 @@
+import { classToHex } from './classToHex'
+import { isCssColor } from './isCssColor'
+
+export const convertToHex = (color: string | undefined): string => {
+	if (typeof color !== 'string') {
+		return '#000'
+	}
+
+	if (isCssColor(color)) {
+		return color
+	}
+
+	switch (color) {
+		case 'white':
+			return '#FFF'
+		case 'black':
+			return '#000'
+		case 'transparent':
+			return 'transparent'
+		default:
+			return classToHex(color) || '#000'
+	}
+}

package/src/utils/functions/isCssColor.ts

@@ -0,0 +1,3 @@
+export function isCssColor(color?: string | false): boolean {
+	return typeof color === 'string' && Boolean(color.match(/^(#|var\(--|(rgb|hsl)a?\()/))
+}

package/src/utils/index.ts

@@ -0,0 +1,45 @@
+// ===========================
+// Storage utilities
+// ===========================
+export { LocalStorageUtility } from './localStorageUtility'
+
+// ===========================
+// Formatting utilities
+// ===========================
+export { calcHumanFileSize } from './calcHumanFileSize'
+export { convertToUnit } from './convertToUnit'
+export { formatDate } from './formatDate'
+export { parseDate } from './parseDate'
+
+// ===========================
+// Validation utilities
+// ===========================
+export { propValidator } from './propValidator'
+export { ruleMessage } from './ruleMessage'
+
+// Date validation
+export { isDateAfter } from './functions/validation/isDateAfter'
+export { isDateBefore } from './functions/validation/isDateBefore'
+export { isDateInRange } from './functions/validation/isDateInRange'
+// Renamed to avoid conflict with rules/isDateValid
+import { isDateValid as isDateValidUtil } from './functions/validation/isDateValid'
+export { isDateValidUtil }
+export { isWeekend } from './functions/validation/isWeekend'
+
+// Email validation
+export { isEmailValid } from './functions/validation/isEmailValid'
+
+// ===========================
+// DOM & Browser utilities
+// ===========================
+export { copyToClipboard } from './functions/copyToClipboard'
+export { downloadFile } from './functions/downloadFile'
+
+// Performance
+import throttleDisplayFn from './functions/throttleDisplayFn/throttleDisplayFn'
+export { throttleDisplayFn }
+
+// ===========================
+// Data utilities
+// ===========================
+export { deepCopy } from './functions/deepCopy'

package/src/vuetifyConfig.ts

@@ -13,6 +13,10 @@ import {
 	paLightTheme,
 	paDarkTheme,
 	paFontsTokens,
+	// apColorsTokens,
+	apContextualTokens,
+	apLightTheme,
+	apDarkTheme,
 } from './designTokens'
 import { createFlattenTheme, createFontVariables } from './designTokens/utils'
 import { fr } from 'vuetify/locale'
@@ -56,6 +60,17 @@ export const createVuetifyInstance = () => createVuetify({
 					...createFontVariables(paFontsTokens),
 				},
 			},
+			ap: {
+				dark: false,
+				colors: {
+					...apLightTheme,
+					...apDarkTheme,
+				},
+				variables: {
+					'font-family': '"Arial", sans-serif',
+					...createFlattenTheme(apContextualTokens),
+				},
+			},
 		},
 	},
 	icons: {

package/dist/SelectFilter-Cj-GW2Cc.js

@@ -1,97 +0,0 @@
-import { defineComponent as m, computed as h, createBlock as v, openBlock as C } from "vue";
-import { S as k, _ as p } from "./main-WDqeoGM-.js";
-const S = /* @__PURE__ */ m({
-  __name: "SelectFilter",
-  props: {
-    header: {
-      type: Object,
-      required: !0
-    },
-    filters: {
-      type: Array,
-      default: () => []
-    },
-    filterValue: {
-      type: [String, Number, Object, void 0],
-      default: void 0
-    },
-    inputConfig: {
-      type: Object,
-      default: () => ({})
-    },
-    disableErrorHandling: {
-      type: Boolean,
-      default: !1
-    },
-    variant: {
-      type: String,
-      default: "outlined"
-    },
-    hideDetails: {
-      type: Boolean,
-      default: !0
-    },
-    density: {
-      type: String,
-      default: "compact"
-    },
-    backgroundColor: {
-      type: String,
-      default: "white"
-    },
-    clearable: {
-      type: Boolean,
-      default: !0
-    }
-  },
-  emits: ["update:filters"],
-  setup(e, { emit: g }) {
-    const t = e, o = g;
-    function u() {
-      return String(t.header.key || t.header.value || (t.header.title ? `filter_${t.header.title}` : `filter_${Date.now()}`));
-    }
-    const s = h({
-      get: () => t.filterValue,
-      set: (l) => {
-        const i = u();
-        if (!i) return;
-        if (l == null) {
-          const r = t.filters.filter((d) => d.key !== i);
-          o("update:filters", r);
-          return;
-        }
-        const a = t.filters.findIndex((r) => r.key === i), n = [...t.filters];
-        a >= 0 ? n[a].value = l : n.push({
-          key: i,
-          value: l,
-          type: "select"
-        }), o("update:filters", n);
-      }
-    });
-    function y() {
-      const l = u(), i = t.filters.filter((a) => a.key !== l);
-      o("update:filters", i);
-    }
-    return (l, i) => {
-      var a, n, r, d, f, c;
-      return C(), v(k, {
-        modelValue: s.value,
-        "onUpdate:modelValue": i[0] || (i[0] = (b) => s.value = b),
-        label: e.header.title,
-        items: e.header.filterOptions,
-        clearable: ((a = e.inputConfig) == null ? void 0 : a.clearable) ?? e.clearable,
-        density: ((n = e.inputConfig) == null ? void 0 : n.density) ?? e.density,
-        "hide-details": ((r = e.inputConfig) == null ? void 0 : r.hideDetails) ?? e.hideDetails,
-        "hide-messages": !0,
-        variant: ((d = e.inputConfig) == null ? void 0 : d.variant) ?? e.variant,
-        "bg-color": ((f = e.inputConfig) == null ? void 0 : f.backgroundColor) ?? e.backgroundColor,
-        "disable-error-handling": ((c = e.inputConfig) == null ? void 0 : c.disableErrorHandling) ?? e.disableErrorHandling,
-        class: "filter-input",
-        "onClick:clear": y
-      }, null, 8, ["modelValue", "label", "items", "clearable", "density", "hide-details", "variant", "bg-color", "disable-error-handling"]);
-    };
-  }
-}), B = /* @__PURE__ */ p(S, [["__scopeId", "data-v-df426b52"]]);
-export {
-  B as default
-};