@design-factory/core 21.1.0-next.1 → 22.0.0-next.0

package/{accordion-D9ba0XYq.js → accordion-B5RqDwi3.js}

@@ -1,9 +1,10 @@
-import { writablesForProps, idWithDefault, stateStores, true$, mergeConfigStores, normalizeConfigStores } from "./utils/stores.js";
+import { writablesForProps, idWithDefault, stateStores, mergeConfigStores, normalizeConfigStores } from "./utils/stores.js";
 import { createTransition } from "./services/transitions/baseTransitions.js";
+import { createCollapseTransition } from "./services/transitions/collapse.js";
 import { writable, computed, readable, asWritable } from "@amadeus-it-group/tansu";
 import { noop } from "./utils/func.js";
-import { j as typeString, e as typeFunction, b as typeBoolean, c as createTypeEnum } from "./writables-DYGjj5T3.js";
-import { s as mergeDirectives, g as createAttributesDirective, u as registrationArray, o as directiveSubscribe } from "./directive-CNNSo5Yn.js";
+import { k as typeString, d as typeBoolean, f as typeFunction, c as createTypeEnum } from "./writables-_7BriMb2.js";
+import { s as mergeDirectives, g as createAttributesDirective, u as registrationArray, o as directiveSubscribe } from "./directive-CMT2vEDg.js";
 import { createWidgetFactory } from "./utils/widget.js";
 function adjustItemsCloseOthers(items, openItems, oldOpen) {
   let keepOpen;
@@ -25,27 +26,40 @@ function adjustItemsCloseOthers(items, openItems, oldOpen) {
 function getItem(items, id) {
   return items.find((item) => item.stores.id$() === id);
 }
+const accordionItemCollapseTransition = createCollapseTransition({
+  showClasses: ["df-collapse-show"],
+  hideClasses: ["df-collapse-hide"],
+  animationPendingClasses: ["df-collapse-collapsing"]
+});
 const defaultAccordionConfig = {
   closeOthers: false,
+  selectable: false,
   onItemShown: noop,
   onItemHidden: noop,
   className: "",
   itemDestroyOnHide: true,
-  itemAnimated: true,
+  animated: true,
   itemTransition: noop,
   itemHeadingLevel: 2,
   itemClassName: "",
   itemHeaderClassName: "",
   itemButtonClassName: "",
   itemBodyContainerClassName: "",
-  itemBodyClassName: ""
+  itemBodyClassName: "",
+  size: "md",
+  arrowPosition: "end",
+  addon: "none",
+  subtitleType: "none",
+  separator: false,
+  ariaToggleButtonLabel: "Toggle item",
+  id: ""
 };
 const defaultItemConfig = {
   id: "",
   destroyOnHide: defaultAccordionConfig.itemDestroyOnHide,
   disabled: false,
   visible: false,
-  animated: defaultAccordionConfig.itemAnimated,
+  animated: defaultAccordionConfig.animated,
   transition: defaultAccordionConfig.itemTransition,
   onShown: noop,
   onHidden: noop,
@@ -63,18 +77,26 @@ function getAccordionDefaultConfig() {
 }
 const configAccordionValidator = {
   closeOthers: typeBoolean,
+  selectable: typeBoolean,
   onItemShown: typeFunction,
   onItemHidden: typeFunction,
   className: typeString,
   itemDestroyOnHide: typeBoolean,
-  itemAnimated: typeBoolean,
+  animated: typeBoolean,
   itemTransition: typeFunction,
   itemClassName: typeString,
   itemHeaderClassName: typeString,
   itemButtonClassName: typeString,
   itemBodyContainerClassName: typeString,
   itemBodyClassName: typeString,
-  itemHeadingLevel: createTypeEnum([1, 2, 3, 4, 5, 6])
+  itemHeadingLevel: createTypeEnum([1, 2, 3, 4, 5, 6]),
+  size: createTypeEnum(["sm", "md", "lg"]),
+  arrowPosition: createTypeEnum(["start", "end"]),
+  addon: createTypeEnum(["none", "icon", "number"]),
+  subtitleType: createTypeEnum(["none", "inline", "block"]),
+  separator: typeBoolean,
+  ariaToggleButtonLabel: typeString,
+  id: typeString
 };
 const configItemValidator = {
   id: typeString,
@@ -140,7 +162,7 @@ function createAccordionItem(config) {
       "aria-controls": computed(() => `${id$()}-body-container`),
       disabled: disabled$
     },
-    classNames: { collapsed: computed(() => !visible$()) },
+    classNames: { "df-collapsed": computed(() => !visible$()) },
     events: {
       click: () => {
         if (!disabled$()) {
@@ -202,10 +224,30 @@ function createAccordionItem(config) {
 function factoryCreateAccordion(itemFactory = createAccordionItem, accordionItemProps = coreAccordionItemProps, accordionConfig = defaultAccordionConfig, accordionValidator = configAccordionValidator) {
   return createWidgetFactory("accordion", (config) => {
     const [writables, patch] = writablesForProps(accordionConfig, config, accordionValidator);
-    const { closeOthers$, onItemShown$, onItemHidden$, className$ } = writables;
+    const {
+      closeOthers$,
+      selectable$,
+      onItemShown$,
+      onItemHidden$,
+      className$,
+      size$,
+      addon$,
+      subtitleType$,
+      separator$,
+      animated$,
+      id$: _dirtyId$,
+      ...stateStores$
+    } = writables;
+    const id$ = idWithDefault(_dirtyId$);
     const accordionItemConfig = Object.fromEntries(
       Object.entries(writables).filter((entry) => entry[0].startsWith("item")).map((entry) => [entry[0].charAt(4).toLowerCase() + entry[0].slice(5, -1), entry[1]])
     );
+    const accordionClassName$ = computed(() => {
+      const size = size$();
+      const sizeClass = size === "sm" ? "df-accordion-sm " : size === "lg" ? "df-accordion-lg " : "";
+      const separatorClass = separator$() ? "df-accordion-separator " : "";
+      return `${sizeClass}${separatorClass}`.trim();
+    });
     const itemWidgets$ = registrationArray();
     const openItems$ = computed(() => {
       const openItems = [];
@@ -218,7 +260,7 @@ function factoryCreateAccordion(itemFactory = createAccordionItem, accordionItem
     });
     const oldOpenItem$ = writable(openItems$()[0]);
     const checkCloseOthersAction$ = computed(() => {
-      if (closeOthers$()) {
+      if (selectable$() || closeOthers$()) {
         adjustItemsCloseOthers(itemWidgets$(), openItems$(), oldOpenItem$());
         oldOpenItem$.set(openItems$()[0]);
       }
@@ -227,22 +269,39 @@ function factoryCreateAccordion(itemFactory = createAccordionItem, accordionItem
       checkCloseOthersAction$();
     });
     return {
-      ...stateStores({ itemWidgets$, className$ }),
+      ...stateStores({
+        itemWidgets$,
+        className$,
+        size$,
+        addon$,
+        subtitleType$,
+        separator$,
+        animated$,
+        accordionClassName$,
+        id$,
+        ...stateStores$
+      }),
       patch,
       api: {
         expand: async (id, animated) => {
           await getItem(itemWidgets$(), id)?.api.expand(animated);
         },
         collapse: async (id, animated) => {
+          if (selectable$()) return;
           await getItem(itemWidgets$(), id)?.api.collapse(animated);
         },
         toggle: async (id, animated) => {
-          await getItem(itemWidgets$(), id)?.api.toggle(animated);
+          if (selectable$()) {
+            await getItem(itemWidgets$(), id)?.api.expand(animated);
+          } else {
+            await getItem(itemWidgets$(), id)?.api.toggle(animated);
+          }
         },
         expandAll: async (animated) => {
           await Promise.all(itemWidgets$().map((i) => i.api.expand(animated)));
         },
         collapseAll: async (animated) => {
+          if (selectable$()) return;
           await Promise.all(itemWidgets$().map((i) => i.api.collapse(animated)));
         },
         registerItem: (propsConfig) => {
@@ -257,12 +316,15 @@ function factoryCreateAccordion(itemFactory = createAccordionItem, accordionItem
               onHidden: defaultItemConfig.onHidden,
               onShown: defaultItemConfig.onShown
             },
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
             { config: config2, props: propsConfig?.props }
           );
           const item = itemFactory({
             config: config2,
             props: {
+              transition: accordionItemCollapseTransition,
               ...propsConfig?.props,
+              animated: animated$,
               onHidden: asWritable(
                 readable(() => {
                   onItemHidden$()(item.stores.id$());
@@ -298,8 +360,7 @@ function factoryCreateAccordion(itemFactory = createAccordionItem, accordionItem
         accordionDirective: mergeDirectives(
           directiveSubscribe(action$),
           createAttributesDirective(() => ({
-            attributes: { class: className$ },
-            classNames: { "au-accordion": true$ }
+            attributes: { class: className$ }
           }))
         )
       }

package/alert-Db6cG6JE.js

@@ -0,0 +1,125 @@
+import { computed } from "@amadeus-it-group/tansu";
+import { c as createCommonAlert } from "./common-CP4amR0Z.js";
+import { c as createCollapse } from "./collapse-D8Jo56k9.js";
+import { createCollapseTransition } from "./services/transitions/collapse.js";
+import { createSimpleClassTransition } from "./services/transitions/simpleClassTransition.js";
+import { extendWidgetProps } from "./services/extendWidget.js";
+import { noop } from "./utils/func.js";
+import { stateStores } from "./utils/stores.js";
+import { f as typeFunction, d as typeBoolean, k as typeString, c as createTypeEnum, t as testToNormalizeValue } from "./writables-_7BriMb2.js";
+import { createWidgetFactory } from "./utils/widget.js";
+const alertRoles = {
+  success: "status",
+  info: "status",
+  tip: "status",
+  warning: "alert",
+  danger: "alert"
+};
+const typeIcons = {
+  normalizeValue: testToNormalizeValue(
+    (value) => !!value && typeof value === "object" && !Array.isArray(value)
+  )
+};
+const alertCollapseTransition = createCollapseTransition({
+  showClasses: ["df-collapse-show"],
+  hideClasses: ["df-collapse-hide"],
+  animationPendingClasses: ["df-collapse-collapsing"]
+});
+const alertFadeTransition = createSimpleClassTransition({
+  animationPendingClasses: ["df-fade"],
+  animationPendingShowClasses: ["df-show"],
+  showClasses: ["df-show", "df-fade"],
+  hideClasses: ["df-hidden", "df-fade"]
+});
+const alertDefaultConfig = {
+  type: "warning",
+  appearance: "default",
+  size: "md",
+  icons: {
+    success: "fa-solid fa-check-circle",
+    warning: "fa-solid fa-exclamation-triangle",
+    danger: "fa-solid fa-octagon-xmark",
+    tip: "fa-solid fa-lightbulb",
+    info: "fa-solid fa-info-circle",
+    default: "fa-solid fa-info-circle"
+  },
+  collapseIcon: "fa-light fa-chevron-up",
+  expandIcon: "fa-light fa-chevron-down",
+  expandLabel: "Show more",
+  collapseLabel: "See less",
+  expandable: false,
+  expanded: false,
+  onCollapsed: noop,
+  onExpanded: noop
+};
+const alertConfigValidator = {
+  type: createTypeEnum(["success", "info", "warning", "danger", "tip"]),
+  appearance: createTypeEnum(["default", "banner"]),
+  size: createTypeEnum(["sm", "md", "lg"]),
+  icons: typeIcons,
+  collapseIcon: typeString,
+  expandIcon: typeString,
+  expandLabel: typeString,
+  collapseLabel: typeString,
+  expandable: typeBoolean,
+  expanded: typeBoolean,
+  onCollapsed: typeFunction,
+  onExpanded: typeFunction
+};
+const createExtendedAlert = extendWidgetProps(
+  createCommonAlert,
+  alertDefaultConfig,
+  alertConfigValidator,
+  {
+    transition: alertFadeTransition
+  }
+);
+const createAlert = createWidgetFactory(
+  "alert",
+  (config) => {
+    const extendedAlert = createExtendedAlert(config);
+    const { onCollapsed$, onExpanded$, ...extendedAlertStores } = extendedAlert.stores;
+    const { icons$, type$, animated$, expandable$, expanded$: requestedExpanded$ } = extendedAlertStores;
+    const collapse = createCollapse({
+      config: {
+        visible: computed(() => expandable$() ? requestedExpanded$() : true),
+        animated: animated$,
+        animatedOnInit: false,
+        transition: alertCollapseTransition,
+        onHidden: () => {
+          if (expandable$()) {
+            onCollapsed$()();
+          }
+        },
+        onShown: () => {
+          if (expandable$()) {
+            onExpanded$()();
+          }
+        }
+      }
+    });
+    const expanded$ = computed(() => expandable$() ? collapse.stores.visible$() : false);
+    const icon$ = computed(() => {
+      const icons = icons$();
+      return icons[type$()] ?? icons.default ?? "";
+    });
+    const role$ = computed(() => alertRoles[type$()]);
+    return {
+      ...extendedAlert,
+      ...stateStores({
+        ...extendedAlertStores,
+        expanded$,
+        icon$,
+        role$
+      }),
+      directives: {
+        ...extendedAlert.directives,
+        collapseDirective: collapse.directives.collapseDirective,
+        collapseTriggerDirective: collapse.directives.triggerDirective
+      }
+    };
+  }
+);
+export {
+  createAlert as c
+};

package/{collapse-Bn8iHKrd.js → collapse-D8Jo56k9.js}

@@ -1,7 +1,7 @@
 import { createTransition } from "./services/transitions/baseTransitions.js";
 import { writablesForProps, idWithDefault, stateStores } from "./utils/stores.js";
-import { g as createAttributesDirective, s as mergeDirectives } from "./directive-CNNSo5Yn.js";
-import { e as typeFunction, j as typeString, b as typeBoolean } from "./writables-DYGjj5T3.js";
+import { g as createAttributesDirective, s as mergeDirectives } from "./directive-CMT2vEDg.js";
+import { f as typeFunction, k as typeString, d as typeBoolean } from "./writables-_7BriMb2.js";
 import { computed } from "@amadeus-it-group/tansu";
 import { noop } from "./utils/func.js";
 import { createWidgetFactory } from "./utils/widget.js";

package/{common-DFyZvkII.js → common-CP4amR0Z.js}

@@ -1,7 +1,7 @@
 import { createTransition } from "./services/transitions/baseTransitions.js";
 import { noop } from "./utils/func.js";
 import { writablesForProps, stateStores } from "./utils/stores.js";
-import { j as typeString, b as typeBoolean, e as typeFunction } from "./writables-DYGjj5T3.js";
+import { k as typeString, d as typeBoolean, f as typeFunction } from "./writables-_7BriMb2.js";
 const defaultCommonAlertConfig = {
   visible: true,
   dismissible: true,
@@ -57,7 +57,7 @@ function createCommonAlert(config) {
   const visible$ = transition.stores.visible$;
   const hidden$ = transition.stores.hidden$;
   return {
-    ...stateStores({ ...stateProps, visible$, hidden$ }),
+    ...stateStores({ ...stateProps, animated$, visible$, hidden$ }),
     patch,
     api: {
       open: transition.api.show,

package/components/accordion/accordion.d.ts

@@ -1,16 +1,82 @@
 import type { TransitionFn } from '../../services/transitions/baseTransitions';
 import type { ConfigValidator, Directive, PropsConfig, Widget, WidgetFactory } from '../../types';
 import type { WidgetsCommonPropsAndState } from '../commonProps';
+/**
+ * Interface representing the common properties and state for an accordion.
+ */
+interface AccordionCommonPropsAndState extends WidgetsCommonPropsAndState {
+    /**
+     * Defines how the subtitle is displayed on accordion items.
+     *
+     * @defaultValue `'none'`
+     */
+    subtitleType: 'none' | 'inline' | 'block';
+    /**
+     * The HTML heading level to use for the accordion-item-header.
+     *
+     * @defaultValue `2`
+     */
+    itemHeadingLevel: 1 | 2 | 3 | 4 | 5 | 6;
+    /**
+     * Accessibility label for the accordion-item toggle button in the interactive variant.
+     *
+     * @defaultValue `'Toggle item'`
+     */
+    ariaToggleButtonLabel: string;
+    /**
+     * The size of the accordion.
+     *
+     * @defaultValue `'md'`
+     */
+    size: 'sm' | 'md' | 'lg';
+    /**
+     * Position of the expandable icon on the accordion header.
+     *
+     * @defaultValue `'end'`
+     */
+    arrowPosition: 'start' | 'end';
+    /**
+     * Addon type to show on the left side of the accordion header.
+     *
+     * @defaultValue `'none'`
+     */
+    addon: 'none' | 'icon' | 'number';
+    /**
+     * When an item is visible (expanded), a separator line is shown below the item header.
+     *
+     * @defaultValue `false`
+     */
+    separator: boolean;
+    /**
+     * The id of the accordion. It is used in the accordion selectable variant.
+     *
+     * @defaultValue `dfId-[number]`
+     */
+    id: string;
+    /**
+     * If `true`, accordion items will be animated.
+     *
+     * @defaultValue `true`
+     */
+    animated: boolean;
+}
 /**
  * Properties for the Accordion component.
  */
-export interface AccordionProps extends WidgetsCommonPropsAndState {
+export interface AccordionProps extends AccordionCommonPropsAndState {
     /**
      * If `true`, only one accordion-item at the time can stay open.
      *
      * @defaultValue `false`
      */
     closeOthers: boolean;
+    /**
+     * If `true`, the accordion uses a radio-group pattern: `closeOthers` is always enforced
+     * and the last open item cannot be collapsed.
+     *
+     * @defaultValue `false`
+     */
+    selectable: boolean;
     /**
      * An event fired when an item is shown.
      *
@@ -39,12 +105,6 @@ export interface AccordionProps extends WidgetsCommonPropsAndState {
      * @defaultValue `true`
      */
     itemDestroyOnHide: boolean;
-    /**
-     * If `true`, accordion-item will be animated.
-     *
-     * @defaultValue `true`
-     */
-    itemAnimated: boolean;
     /**
      * The transition to use for the accordion-item body-container when the accordion-item is toggled.
      *
@@ -85,21 +145,19 @@ export interface AccordionProps extends WidgetsCommonPropsAndState {
      * @defaultValue `''`
      */
     itemBodyClassName: string;
-    /**
-     * The html heading level to use for the accordion-item-header.
-     *
-     * @defaultValue `2`
-     */
-    itemHeadingLevel: 1 | 2 | 3 | 4 | 5 | 6;
 }
 /**
  * Represents the state of an Accordion component.
  */
-export interface AccordionState extends WidgetsCommonPropsAndState {
+export interface AccordionState extends AccordionCommonPropsAndState {
     /**
      * Array containing all the accordion-items contained in the accordion.
      */
     itemWidgets: AccordionItemWidget[];
+    /**
+     * Computed CSS class name for the accordion based on its visual configuration.
+     */
+    accordionClassName: string;
 }
 /**
  * Interface representing the API for an accordion component.
@@ -254,7 +312,7 @@ interface AccordionItemCommonPropsAndState extends WidgetsCommonPropsAndState {
      */
     bodyClassName: string;
     /**
-     * The html heading level to use for the accordion-item-header.
+     * The HTML heading level to use for the accordion-item-header.
      */
     headingLevel: 1 | 2 | 3 | 4 | 5 | 6;
 }

package/components/accordion/index.js

@@ -1,4 +1,4 @@
-import { c, a, f, g } from "../../accordion-D9ba0XYq.js";
+import { c, a, f, g } from "../../accordion-B5RqDwi3.js";
 export {
   c as createAccordion,
   a as createAccordionItem,

package/components/alert/alert.d.ts

@@ -1,14 +1,79 @@
 import type { CommonAlertApi, CommonAlertDirectives, CommonAlertProps, CommonAlertState } from './common';
-import type { Widget, WidgetFactory } from '../../types';
+import type { Directive, Widget, WidgetFactory } from '../../types';
+export type AlertSize = 'sm' | 'md' | 'lg';
+export type AlertType = 'success' | 'info' | 'warning' | 'danger' | 'tip';
+export type AlertRole = 'alert' | 'status';
+export type AlertAppearance = 'default' | 'banner';
+type AlertIcons = Record<AlertType | 'default', string>;
+interface AlertExtraPropsAndState {
+    /**
+     * Type of the alert.
+     */
+    type: AlertType;
+    /**
+     * Visual appearance variant for alert chrome.
+     */
+    appearance: AlertAppearance;
+    /**
+     * Size of the alert.
+     */
+    size: AlertSize;
+    /**
+     * Icon classes by alert type.
+     */
+    icons: AlertIcons;
+    /**
+     * Icon class for the collapse action.
+     */
+    collapseIcon: string;
+    /**
+     * Icon class for the expand action.
+     */
+    expandIcon: string;
+    /**
+     * Label shown when alert details can be expanded.
+     */
+    expandLabel: string;
+    /**
+     * Label shown when alert details can be collapsed.
+     */
+    collapseLabel: string;
+    /**
+     * If `true`, alert details can be toggled with a collapse trigger.
+     */
+    expandable: boolean;
+    /**
+     * If `true`, the collapsible content is shown.
+     */
+    expanded: boolean;
+}
+interface AlertExtraProps extends AlertExtraPropsAndState {
+    /**
+     * Callback called when collapsible content is hidden.
+     */
+    onCollapsed: () => void;
+    /**
+     * Callback called when collapsible content is shown.
+     */
+    onExpanded: () => void;
+}
 /**
  * Represents the state of an alert component.
  */
-export interface AlertState extends CommonAlertState {
+export interface AlertState extends CommonAlertState, AlertExtraPropsAndState {
+    /**
+     * Computed icon class for current alert type.
+     */
+    icon: string;
+    /**
+     * Computed ARIA live region role for current alert type.
+     */
+    role: AlertRole;
 }
 /**
  * Represents the properties for the alert component.
  */
-export interface AlertProps extends CommonAlertProps {
+export interface AlertProps extends CommonAlertProps, AlertExtraProps {
 }
 /**
  * Represents the API for an alert component.
@@ -19,19 +84,23 @@ export interface AlertApi extends CommonAlertApi {
  * Represents the directives for an alert component.
  */
 export interface AlertDirectives extends CommonAlertDirectives {
+    /**
+     * Directive to apply the collapse animation to alert details.
+     */
+    collapseDirective: Directive;
+    /**
+     * Directive to apply on the collapse trigger element.
+     */
+    collapseTriggerDirective: Directive;
 }
 /**
  * Represents an alert widget with specific properties, state, API, and directives.
  */
 export type AlertWidget = Widget<AlertProps, AlertState, AlertApi, AlertDirectives>;
-/**
- * Retrieve a shallow copy of the default alert config
- * @returns the default alert config
- */
-export declare function getAlertDefaultConfig(): AlertProps;
 /**
  * Create an AlertWidget with given config props
  * @param config - an optional alert config
  * @returns an AlertWidget
  */
 export declare const createAlert: WidgetFactory<AlertWidget>;
+export {};

package/components/alert/common.d.ts

@@ -24,6 +24,15 @@ export interface CommonAlertCommonPropsAndState extends WidgetsCommonPropsAndSta
      * @defaultValue `'Close'`
      */
     ariaCloseButtonLabel: string;
+    /**
+     * If `true`, the alert closing will be animated.
+     *
+     * Animation is triggered when clicked on the close button (×),
+     * via the `.close()` function or the visible prop is changed
+     *
+     * @defaultValue `true`
+     */
+    animated: boolean;
 }
 /**
  * Represents the state of a common alert component.
@@ -85,15 +94,6 @@ export interface CommonAlertProps extends CommonAlertCommonPropsAndState {
      * @defaultValue `false`
      */
     animatedOnInit: boolean;
-    /**
-     * If `true`, alert closing will be animated.
-     *
-     * Animation is triggered  when clicked on the close button (×),
-     * via the `.close()` function or the visible prop is changed
-     *
-     * @defaultValue `true`
-     */
-    animated: boolean;
 }
 /**
  * Interface representing the common API for alert components.

package/components/alert/index.js

@@ -1,5 +1,4 @@
-import { c, g } from "../../alert-Cb9FhbFQ.js";
+import { c } from "../../alert-Db6cG6JE.js";
 export {
-  c as createAlert,
-  g as getAlertDefaultConfig
+  c as createAlert
 };

package/components/carousel/index.js

@@ -1,8 +1,8 @@
 import { writablesForProps, true$, stateStores } from "../../utils/stores.js";
-import { b as bindDirective, d as browserDirective, g as createAttributesDirective, s as mergeDirectives } from "../../directive-CNNSo5Yn.js";
+import { b as bindDirective, d as browserDirective, g as createAttributesDirective, s as mergeDirectives } from "../../directive-CMT2vEDg.js";
 import EmblaCarousel from "embla-carousel";
 import { writable, computed, asReadable, readable } from "@amadeus-it-group/tansu";
-import { e as typeFunction, j as typeString, b as typeBoolean, g as typeNumber, k as typeStringOrNull, a as typeArray, c as createTypeEnum } from "../../writables-DYGjj5T3.js";
+import { f as typeFunction, k as typeString, d as typeBoolean, h as typeNumber, l as typeStringOrNull, b as typeArray, c as createTypeEnum } from "../../writables-_7BriMb2.js";
 import { createNavManager } from "../../services/navManager.js";
 import { createWidgetFactory } from "../../utils/widget.js";
 const defaultConfig = {

package/components/collapse/index.js

@@ -1,4 +1,4 @@
-import { c, g } from "../../collapse-Bn8iHKrd.js";
+import { c, g } from "../../collapse-D8Jo56k9.js";
 export {
   c as createCollapse,
   g as getCollapseDefaultConfig

package/components/drawer/drawer.d.ts

@@ -125,6 +125,12 @@ export interface DrawerProps extends DrawerCommonPropsAndState {
      * @defaultValue `true`
      */
     backdrop: boolean;
+    /**
+     * If `true` the drawer will be closed when clicking on the backdrop, otherwise the backdrop is static and non iteractive.
+     *
+     * @defaultValue `true`
+     */
+    closeOnBackdropClick: boolean;
     /**
      * If `true` allows body scrolling when the drawer is open.
      *