@surgeui/ds-vue 2.1.0 → 2.3.0

package/dist/components/atoms/Panel.vue.d.ts

@@ -13,9 +13,9 @@ type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<PanelProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PanelProps> & Readonly<{}>, {
     variant: "default" | "subtle" | "highlight";
     radius: import('../../types').Radius;
+    elevated: boolean;
     tag: "div" | "section" | "article" | "aside" | "header" | "footer";
     bordered: boolean;
-    elevated: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/atoms/Price.vue.d.ts

@@ -0,0 +1,47 @@
+import { PriceProps } from '../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Contenu avant le prix (ex: "À partir de", "Dès") */
+        prefix?(): any;
+        /** Rendu personnalisé du prix barré original */
+        original?(props: {
+            formatted: string;
+            amount: number;
+        }): any;
+        /** Contenu après le prix (ex: "/mois", "TTC", Badge) */
+        suffix?(): any;
+    }> & {
+        /** Contenu avant le prix (ex: "À partir de", "Dès") */
+        prefix?(): any;
+        /** Rendu personnalisé du prix barré original */
+        original?(props: {
+            formatted: string;
+            amount: number;
+        }): any;
+        /** Contenu après le prix (ex: "/mois", "TTC", Badge) */
+        suffix?(): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<PriceProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PriceProps> & Readonly<{}>, {
+    size: import('../../types').PriceSize;
+    variant: import('../../types').PriceVariant;
+    currency: string;
+    locale: string;
+    integerOnly: boolean;
+    showOriginal: boolean;
+    currencyDisplay: import('../../types').CurrencyDisplay;
+    currencyPosition: import('../../types').CurrencyPosition;
+    superscriptDecimals: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=Price.vue.d.ts.map

package/dist/components/atoms/Price.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Price.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/Price.vue"],"names":[],"mappings":"AA8WA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AA+HzC,iBAAS,cAAc;WAqFT,OAAO,IAA6B;;QAnMhD,uDAAuD;mBAC5C,GAAG;QACd,gDAAgD;yBAC/B;YAAE,SAAS,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,GAAG,GAAG;QAC5D,wDAAwD;mBAC7C,GAAG;;QALd,uDAAuD;mBAC5C,GAAG;QACd,gDAAgD;yBAC/B;YAAE,SAAS,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,GAAG,GAAG;QAC5D,wDAAwD;mBAC7C,GAAG;;;;EAmMf;AAgBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;yFAQnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/atoms/Toggle.vue.d.ts

@@ -0,0 +1,19 @@
+import { ToggleProps } from '../../types';
+type __VLS_Props = ToggleProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: boolean) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    size: import('../../types').Size;
+    variant: import('../../types').ToggleVariant;
+    radius: import('../../types').Radius;
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+export default _default;
+//# sourceMappingURL=Toggle.vue.d.ts.map

package/dist/components/atoms/Toggle.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Toggle.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/Toggle.vue"],"names":[],"mappings":"AAiOA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,KAAK,WAAW,GAAG,WAAW,CAAC;AAoE/B,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,WAAW,CAAC;;;;;;;;;;;;;AAiFhB,wBASG"}

package/dist/components/molecules/OtpInput.vue.d.ts

@@ -0,0 +1,57 @@
+import { OtpInputProps } from '../../types';
+type __VLS_Props = OtpInputProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Contenu personnalisé du séparateur entre groupes */
+        separator?(): any;
+    }> & {
+        /** Contenu personnalisé du séparateur entre groupes */
+        separator?(): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    focus: () => void;
+    clear: () => void;
+    inputRefs: import('vue').ShallowRef<(HTMLInputElement | null)[], (HTMLInputElement | null)[]>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: (event: FocusEvent, index: number) => any;
+    blur: (event: FocusEvent, index: number) => any;
+    change: (value: string) => any;
+    "update:modelValue": (value: string) => any;
+    complete: (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onFocus?: ((event: FocusEvent, index: number) => any) | undefined;
+    onBlur?: ((event: FocusEvent, index: number) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onComplete?: ((value: string) => any) | undefined;
+}>, {
+    size: import('../../types').Size;
+    variant: import('../../types').OtpVariant;
+    disabled: boolean;
+    state: import('../../types').State;
+    required: boolean;
+    readonly: boolean;
+    placeholder: string;
+    separator: string;
+    length: number;
+    inputType: import('../../types').OtpInputType;
+    masked: boolean;
+    autoSubmit: boolean;
+    autoFocus: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=OtpInput.vue.d.ts.map

package/dist/components/molecules/OtpInput.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OtpInput.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/OtpInput.vue"],"names":[],"mappings":"AAkvBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAI5C,KAAK,WAAW,GAAG,aAAa,CAAC;AAuYjC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAwFT,OAAO,IAA6B;;QA1chD,uDAAuD;sBACzC,GAAG;;QADjB,uDAAuD;sBACzC,GAAG;;;;EA8clB;AAuBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EASnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/molecules/OtpInputField.vue.d.ts

@@ -0,0 +1,173 @@
+import { OtpInputFieldProps } from '../../types';
+type __VLS_Props = OtpInputFieldProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    focus: () => void | undefined;
+    clear: () => void | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: (event: FocusEvent, index: number) => any;
+    blur: (event: FocusEvent, index: number) => any;
+    change: (value: string) => any;
+    "update:modelValue": (value: string) => any;
+    complete: (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onFocus?: ((event: FocusEvent, index: number) => any) | undefined;
+    onBlur?: ((event: FocusEvent, index: number) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onComplete?: ((value: string) => any) | undefined;
+}>, {
+    size: import('../../types').Size;
+    variant: import('../../types').OtpVariant;
+    disabled: boolean;
+    state: import('../../types').State;
+    required: boolean;
+    readonly: boolean;
+    placeholder: string;
+    separator: string;
+    length: number;
+    inputType: import('../../types').OtpInputType;
+    masked: boolean;
+    autoSubmit: boolean;
+    autoFocus: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    otpInputRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: string | undefined;
+            readonly length?: number | undefined;
+            readonly variant?: import('../../types').OtpVariant | undefined;
+            readonly inputType?: import('../../types').OtpInputType | undefined;
+            readonly pattern?: string | undefined;
+            readonly validate?: ((char: string, index: number) => boolean) | undefined;
+            readonly size?: import('../../types').Size | undefined;
+            readonly state?: import('../../types').State | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly required?: boolean | undefined;
+            readonly masked?: boolean | undefined;
+            readonly grouping?: number[] | undefined;
+            readonly separator?: string | undefined;
+            readonly autoSubmit?: boolean | undefined;
+            readonly placeholder?: string | undefined;
+            readonly autoFocus?: boolean | undefined;
+            readonly ariaLabel?: string | undefined;
+            readonly ariaLabelledBy?: string | undefined;
+            readonly ariaDescribedBy?: string | undefined;
+            readonly ariaHidden?: boolean | undefined;
+            readonly ariaInvalid?: boolean | undefined;
+            readonly ariaRequired?: boolean | undefined;
+            readonly ariaValueText?: string | undefined;
+            readonly role?: string | undefined;
+            readonly tabIndex?: number | undefined;
+            readonly onFocus?: ((event: FocusEvent, index: number) => any) | undefined;
+            readonly onBlur?: ((event: FocusEvent, index: number) => any) | undefined;
+            readonly onChange?: ((value: string) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            readonly onComplete?: ((value: string) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "focus", event: FocusEvent, index: number) => void) & ((event: "blur", event: FocusEvent, index: number) => void) & ((event: "change", value: string) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "complete", value: string) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            modelValue?: string;
+        } & import('../../types').OtpInputProps> & Readonly<{
+            onFocus?: ((event: FocusEvent, index: number) => any) | undefined;
+            onBlur?: ((event: FocusEvent, index: number) => any) | undefined;
+            onChange?: ((value: string) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onComplete?: ((value: string) => any) | undefined;
+        }>, {
+            focus: () => void;
+            clear: () => void;
+            inputRefs: import('vue').ShallowRef<(HTMLInputElement | null)[], (HTMLInputElement | null)[]>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            focus: (event: FocusEvent, index: number) => any;
+            blur: (event: FocusEvent, index: number) => any;
+            change: (value: string) => any;
+            "update:modelValue": (value: string) => any;
+            complete: (value: string) => any;
+        }, string, {
+            size: import('../../types').Size;
+            variant: import('../../types').OtpVariant;
+            disabled: boolean;
+            state: import('../../types').State;
+            required: boolean;
+            readonly: boolean;
+            placeholder: string;
+            separator: string;
+            length: number;
+            inputType: import('../../types').OtpInputType;
+            masked: boolean;
+            autoSubmit: boolean;
+            autoFocus: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        size: import('../../types').Size;
+        variant: import('../../types').OtpVariant;
+        disabled: boolean;
+        state: import('../../types').State;
+        required: boolean;
+        readonly: boolean;
+        placeholder: string;
+        separator: string;
+        length: number;
+        inputType: import('../../types').OtpInputType;
+        masked: boolean;
+        autoSubmit: boolean;
+        autoFocus: boolean;
+    }> & Omit<Readonly<{
+        modelValue?: string;
+    } & import('../../types').OtpInputProps> & Readonly<{
+        onFocus?: ((event: FocusEvent, index: number) => any) | undefined;
+        onBlur?: ((event: FocusEvent, index: number) => any) | undefined;
+        onChange?: ((value: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onComplete?: ((value: string) => any) | undefined;
+    }>, "focus" | "clear" | "inputRefs" | ("size" | "variant" | "disabled" | "state" | "required" | "readonly" | "placeholder" | "separator" | "length" | "inputType" | "masked" | "autoSubmit" | "autoFocus")> & import('vue').ShallowUnwrapRef<{
+        focus: () => void;
+        clear: () => void;
+        inputRefs: import('vue').ShallowRef<(HTMLInputElement | null)[], (HTMLInputElement | null)[]>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<{
+            separator?(): any;
+        }> & {
+            separator?(): any;
+        };
+    }) | null;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=OtpInputField.vue.d.ts.map

package/dist/components/molecules/OtpInputField.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OtpInputField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/OtpInputField.vue"],"names":[],"mappings":"AAmFA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAEjD,KAAK,WAAW,GAAG,kBAAkB,CAAC;AAuEtC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAgJsohB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAzB5whB,wBAWG"}

package/dist/components/molecules/ToggleGroup.vue.d.ts

@@ -0,0 +1,24 @@
+import { ToggleGroupProps } from '../../types';
+type __VLS_Props = ToggleGroupProps;
+type __VLS_PublicProps = {
+    modelValue?: (string | number)[];
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (item: string | number, active: boolean) => any;
+    change: (value: (string | number)[]) => any;
+    "update:modelValue": (value: (string | number)[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSelect?: ((item: string | number, active: boolean) => any) | undefined;
+    onChange?: ((value: (string | number)[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+}>, {
+    size: import('../../types').Size;
+    variant: import('../../types').ToggleVariant;
+    radius: import('../../types').Radius;
+    disabled: boolean;
+    orientation: import('../../types').Orientation;
+    gap: import('../../types').Gap;
+    mode: import('../../types').ToggleGroupMode;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=ToggleGroup.vue.d.ts.map

package/dist/components/molecules/ToggleGroup.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToggleGroup.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/ToggleGroup.vue"],"names":[],"mappings":"AAiKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C,KAAK,WAAW,GAAG,gBAAgB,CAAC;AA6EpC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;CAChC,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;AAgGhB,wBASG"}

package/dist/components/organisms/Card.vue.d.ts

@@ -0,0 +1,28 @@
+import { CardProps } from '../../types';
+declare function __VLS_template(): any;
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<CardProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<CardProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    size: import('../../types').CardSize;
+    variant: import('../../types').CardVariant;
+    clickable: boolean;
+    radius: import('../../types').Radius;
+    disabled: boolean;
+    direction: import('../../types').CardDirection;
+    imageRatio: "16/9" | "4/3" | "1/1" | "21/9" | "auto";
+    imageFit: "cover" | "contain" | "fill";
+    imagePosition: "top" | "bottom";
+    titleLevel: 1 | 2 | 3 | 4 | 5 | 6;
+    fullWidth: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=Card.vue.d.ts.map

package/dist/components/organisms/Card.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Card.vue.d.ts","sourceRoot":"","sources":["../../../src/components/organisms/Card.vue"],"names":[],"mappings":"AA4jBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAsJxC,iBAAS,cAAc,QAwItB;AAiBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;6EASnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/composables/index.d.ts

@@ -1,5 +1,7 @@
 import { useTheme } from './useTheme';
 import { useCustomTheme } from './useCustomTheme';
 import { useUniqueId } from './useUniqueId';
-export { useTheme, useCustomTheme, useUniqueId, };
+import { useBreakpoint } from './useBreakpoint';
+import { usePrice } from './usePrice';
+export { useTheme, useCustomTheme, useUniqueId, useBreakpoint, usePrice, };
 //# sourceMappingURL=index.d.ts.map

package/dist/composables/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composables/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,EACL,QAAQ,EACR,cAAc,EACd,WAAW,GACZ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composables/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,OAAO,EACL,QAAQ,EACR,cAAc,EACd,WAAW,EACX,aAAa,EACb,QAAQ,GACT,CAAA"}

package/dist/composables/useBreakpoint.d.ts

@@ -0,0 +1,83 @@
+export type BreakpointKey = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+export interface BreakpointConfig {
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+    '2xl'?: number;
+}
+export interface UseBreakpointOptions {
+    /** Surcharge des breakpoints par défaut */
+    breakpoints?: BreakpointConfig;
+}
+export interface BreakpointMatches {
+    sm: boolean;
+    md: boolean;
+    lg: boolean;
+    xl: boolean;
+    '2xl': boolean;
+}
+/**
+ * Composable pour la détection réactive des breakpoints.
+ *
+ * Utilise `window.matchMedia` pour une détection performante
+ * sans écouter l'événement `resize`. Compatible SSR (valeurs
+ * neutres côté serveur).
+ *
+ * @example
+ * ```ts
+ * const { current, isUp, isDown, isBetween, matches } = useBreakpoint()
+ *
+ * // Breakpoint actif
+ * current.value // 'md'
+ *
+ * // Vérifications
+ * isUp('md')    // true si largeur >= 768px
+ * isDown('lg')  // true si largeur < 1024px
+ * isBetween('sm', 'lg') // true si >= 640px et < 1024px
+ *
+ * // Objet réactif complet
+ * matches.value // { sm: true, md: true, lg: false, xl: false, '2xl': false }
+ * ```
+ */
+export declare function useBreakpoint(options?: UseBreakpointOptions): {
+    /** Breakpoint actif le plus large ('xs' si aucun) */
+    current: import('vue').ComputedRef<"xs" | BreakpointKey>;
+    /** Largeur du viewport en pixels (réactif) */
+    width: Readonly<import('vue').Ref<number, number>>;
+    /** Objet réactif { sm: bool, md: bool, lg: bool, xl: bool, '2xl': bool } */
+    matches: Readonly<import('vue').Ref<{
+        readonly sm: boolean;
+        readonly md: boolean;
+        readonly lg: boolean;
+        readonly xl: boolean;
+        readonly '2xl': boolean;
+    }, {
+        readonly sm: boolean;
+        readonly md: boolean;
+        readonly lg: boolean;
+        readonly xl: boolean;
+        readonly '2xl': boolean;
+    }>>;
+    /** true si largeur >= breakpoint */
+    isUp: (breakpoint: BreakpointKey) => boolean;
+    /** true si largeur < breakpoint */
+    isDown: (breakpoint: BreakpointKey) => boolean;
+    /** true si largeur >= min et < max */
+    isBetween: (min: BreakpointKey, max: BreakpointKey) => boolean;
+    /** Configuration des breakpoints utilisée */
+    breakpoints: Readonly<import('vue').Ref<{
+        readonly sm: number;
+        readonly md: number;
+        readonly lg: number;
+        readonly xl: number;
+        readonly '2xl': number;
+    }, {
+        readonly sm: number;
+        readonly md: number;
+        readonly lg: number;
+        readonly xl: number;
+        readonly '2xl': number;
+    }>>;
+};
+//# sourceMappingURL=useBreakpoint.d.ts.map

package/dist/composables/useBreakpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBreakpoint.d.ts","sourceRoot":"","sources":["../../src/composables/useBreakpoint.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,CAAA;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,oBAAoB;IACnC,2CAA2C;IAC3C,WAAW,CAAC,EAAE,gBAAgB,CAAA;CAC/B;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,OAAO,CAAA;IACX,EAAE,EAAE,OAAO,CAAA;IACX,EAAE,EAAE,OAAO,CAAA;IACX,EAAE,EAAE,OAAO,CAAA;IACX,KAAK,EAAE,OAAO,CAAA;CACf;AA2BD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB;IAkJ5D,qDAAqD;;IAGrD,8CAA8C;;IAG9C,4EAA4E;;qBA/M1E,OAAO;qBACP,OAAO;qBACP,OAAO;qBACP,OAAO;wBACJ,OAAO;;qBAJV,OAAO;qBACP,OAAO;qBACP,OAAO;qBACP,OAAO;wBACJ,OAAO;;IA8MZ,oCAAoC;uBAhFZ,aAAa,KAAG,OAAO;IAmF/C,mCAAmC;yBA5ET,aAAa,KAAG,OAAO;IA+EjD,sCAAsC;qBAxEhB,aAAa,OAAO,aAAa,KAAG,OAAO;IA2EjE,6CAA6C;;qBAxO1C,MAAM;qBACN,MAAM;qBACN,MAAM;qBACN,MAAM;wBACH,MAAM;;qBAJT,MAAM;qBACN,MAAM;qBACN,MAAM;qBACN,MAAM;wBACH,MAAM;;EAuOf"}

package/dist/composables/usePrice.d.ts

@@ -0,0 +1,85 @@
+import { Ref } from 'vue';
+import { CurrencyDisplay } from '../types';
+export interface UsePriceOptions {
+    /** Montant numérique. Accepte un ref, un getter, ou un nombre statique. */
+    amount: number | Ref<number> | (() => number);
+    /** Code devise ISO 4217 (ex: 'EUR', 'USD', 'GBP'). Défaut: 'EUR' */
+    currency?: string;
+    /** Locale BCP 47 (ex: 'fr-FR', 'en-US'). Défaut: 'fr-FR' */
+    locale?: string;
+    /** Affichage de la devise. Défaut: 'symbol' */
+    currencyDisplay?: CurrencyDisplay;
+    /** Nombre minimum de chiffres décimaux. Défaut: 2 */
+    minimumFractionDigits?: number;
+    /** Nombre maximum de chiffres décimaux. Défaut: 2 */
+    maximumFractionDigits?: number;
+    /**
+     * Formatter personnalisé. Quand fourni, remplace Intl.NumberFormat.
+     * Utile pour des formats spéciaux ("Gratuit", "Sur devis", etc.)
+     */
+    formatValue?: (amount: number, currency: string, locale: string) => string;
+}
+export interface UsePriceReturn {
+    /** Prix formaté complet (ex: "1 299,99 €") */
+    formatted: Readonly<Ref<string>>;
+    /** Partie entière uniquement (ex: "1 299") */
+    integerPart: Readonly<Ref<string>>;
+    /** Partie décimale sans séparateur (ex: "99") */
+    decimalPart: Readonly<Ref<string>>;
+    /** Séparateur décimal de la locale (ex: "," pour fr-FR) */
+    decimalSeparator: Readonly<Ref<string>>;
+    /** Symbole de la devise (ex: "€", "$", "£") */
+    currencySymbol: Readonly<Ref<string>>;
+    /** true si le symbole est positionné avant le montant */
+    isSymbolPrefix: Readonly<Ref<boolean>>;
+    /** Texte accessible pour les lecteurs d'écran (ex: "1 299,99 euros") */
+    ariaLabel: Readonly<Ref<string>>;
+    /** Montant numérique brut résolu */
+    rawAmount: Readonly<Ref<number>>;
+}
+/**
+ * Composable pour le formatage réactif des prix.
+ *
+ * Utilise `Intl.NumberFormat` pour un formatage correct selon
+ * la locale et la devise. Expose les différentes parties du prix
+ * pour un rendu flexible dans les composants.
+ *
+ * Compatible SSR — `Intl.NumberFormat` est disponible dans Node.js.
+ *
+ * @example
+ * ```ts
+ * const { formatted, integerPart, decimalPart, currencySymbol } = usePrice({
+ *   amount: 1299.99,
+ *   currency: 'EUR',
+ *   locale: 'fr-FR',
+ * })
+ *
+ * formatted.value      // "1 299,99 €"
+ * integerPart.value    // "1 299"
+ * decimalPart.value    // "99"
+ * currencySymbol.value // "€"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Avec un ref réactif
+ * const amount = ref(49.99)
+ * const { formatted } = usePrice({ amount })
+ *
+ * amount.value = 29.99
+ * formatted.value // "29,99 €"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Avec formatter personnalisé
+ * const { formatted } = usePrice({
+ *   amount: 0,
+ *   formatValue: (amt) => amt === 0 ? 'Gratuit' : `${amt} €`,
+ * })
+ *
+ * formatted.value // "Gratuit"
+ * ```
+ */
+export declare function usePrice(options: UsePriceOptions): UsePriceReturn;
+//# sourceMappingURL=usePrice.d.ts.map

package/dist/composables/usePrice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePrice.d.ts","sourceRoot":"","sources":["../../src/composables/usePrice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAM9C,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,MAAM,CAAC,CAAA;IAC7C,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,+CAA+C;IAC/C,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,qDAAqD;IACrD,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,qDAAqD;IACrD,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;CAC3E;AAED,MAAM,WAAW,cAAc;IAC7B,8CAA8C;IAC9C,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IAChC,8CAA8C;IAC9C,WAAW,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IAClC,iDAAiD;IACjD,WAAW,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IAClC,2DAA2D;IAC3D,gBAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IACvC,+CAA+C;IAC/C,cAAc,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IACrC,yDAAyD;IACzD,cAAc,EAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IACtC,wEAAwE;IACxE,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IAChC,oCAAoC;IACpC,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;CACjC;AAmKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,CA4GjE"}