@agnos-ui/svelte-bootstrap 0.3.1 → 0.4.0-next.1

package/components/alert/AlertDefaultStructure.svelte

@@ -1,12 +1,11 @@
 <script>import { Slot } from "@agnos-ui/svelte-headless/slot";
 export let state;
 export let widget;
-$:
-  slotContext = { widget, state };
+$: slotContext = { widget, state };
 </script>
 
 <div class="alert-body">
-	<Slot slotContent={state.slotDefault} props={slotContext} let:component let:props>
+	<Slot slotContent={state.children} props={slotContext} let:component let:props>
 		<svelte:fragment slot="slot" let:props><slot {...props} /></svelte:fragment>
 		<svelte:component this={component} {...props}>
 			<svelte:fragment let:state let:widget><slot {state} {widget} /></svelte:fragment>

package/components/alert/AlertDefaultStructure.svelte.d.ts

@@ -1,15 +1,17 @@
-import { SvelteComponentTyped } from "svelte";
-import type { AlertContext, AlertSlots } from './alert';
+import { SvelteComponent } from "svelte";
+import type { AlertSlots } from './alert';
 declare const __propDef: {
-    props: AlertContext;
+    props: WidgetSlotContext<Widget<import("./alert.gen").AlertProps, import("./alert.gen").AlertState, import("./alert.gen").AlertApi, object, import("./alert.gen").AlertDirectives>>;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: AlertSlots;
+    exports?: {} | undefined;
+    bindings?: string | undefined;
 };
 export type AlertDefaultStructureProps = typeof __propDef.props;
 export type AlertDefaultStructureEvents = typeof __propDef.events;
 export type AlertDefaultStructureSlots = typeof __propDef.slots;
-export default class AlertDefaultStructure extends SvelteComponentTyped<AlertDefaultStructureProps, AlertDefaultStructureEvents, AlertDefaultStructureSlots> {
+export default class AlertDefaultStructure extends SvelteComponent<AlertDefaultStructureProps, AlertDefaultStructureEvents, AlertDefaultStructureSlots> {
 }
 export {};

package/components/alert/alert.d.ts

@@ -1,16 +1,7 @@
-export * from '@agnos-ui/core-bootstrap/components/alert';
-import type { AdaptWidgetSlots, WidgetPropsSlots, WidgetFactory, WidgetProps, WidgetState, PropType, AdaptSlotContentProps } from '@agnos-ui/svelte-headless/types';
-import type { AlertWidget as CoreWidget, AlertContext as CoreContext } from '@agnos-ui/core-bootstrap/components/alert';
-export interface AlertWidget extends AdaptWidgetSlots<CoreWidget> {
-}
-export interface AlertProps extends WidgetProps<AlertWidget> {
-}
-export interface AlertState extends WidgetState<AlertWidget> {
-}
-export interface AlertApi extends PropType<AlertWidget, 'api'> {
-}
+import type { WidgetPropsSlots, WidgetFactory } from '@agnos-ui/svelte-headless/types';
+import type { AlertProps, AlertWidget } from './alert.gen';
+export type * from './alert.gen';
+export declare const createAlert: WidgetFactory<AlertWidget>;
+export declare const getAlertDefaultConfig: () => AlertProps;
 export interface AlertSlots extends WidgetPropsSlots<AlertProps> {
 }
-export interface AlertContext extends AdaptSlotContentProps<CoreContext> {
-}
-export declare const createAlert: WidgetFactory<AlertWidget>;

package/components/alert/alert.gen.d.ts

@@ -0,0 +1,119 @@
+import type { WidgetSlotContext, SlotContent, Widget, Directive } from '@agnos-ui/svelte-headless/types';
+import type { BSContextualClass } from '@agnos-ui/core-bootstrap/types';
+import type { TransitionFn } from '@agnos-ui/svelte-headless/services/transitions/baseTransitions';
+export type AlertContext = WidgetSlotContext<AlertWidget>;
+export interface AlertState {
+    /**
+     * Is `true` when the alert is hidden. Compared to `visible`, this is updated after the transition is executed.
+     */
+    hidden: boolean;
+    /**
+     * If `true`, alert can be dismissed by the user.
+     * The close button (×) will be displayed and you can be notified of the event with the (close) output.
+     */
+    dismissible: boolean;
+    /**
+     * If `true` the alert is visible to the user
+     */
+    visible: boolean;
+    /**
+     * Accessibility close button label
+     */
+    ariaCloseButtonLabel: string;
+    /**
+     * CSS classes to be applied on the widget main container
+     */
+    className: string;
+    /**
+     * Global template for the alert component
+     */
+    structure: SlotContent<AlertContext>;
+    /**
+     * Template for the alert content
+     */
+    children: SlotContent<AlertContext>;
+    /**
+     * Type of the alert, following bootstrap types.
+     */
+    type: BSContextualClass;
+}
+export interface AlertProps {
+    /**
+     * Callback called when the alert visibility changed.
+     */
+    onVisibleChange: (visible: boolean) => void;
+    /**
+     * Callback called when the alert is hidden.
+     */
+    onHidden: () => void;
+    /**
+     * Callback called when the alert is shown.
+     */
+    onShown: () => void;
+    /**
+     * The transition function will be executed when the alert is displayed or hidden.
+     *
+     * Depending on the value of `animatedOnInit`, the animation can be optionally skipped during the showing process.
+     */
+    transition: TransitionFn;
+    /**
+     * If `true`, alert opening will be animated.
+     *
+     * Animation is triggered  when the `.open()` function is called
+     * or the visible prop is changed
+     */
+    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
+     */
+    animated: boolean;
+    /**
+     * If `true`, alert can be dismissed by the user.
+     * The close button (×) will be displayed and you can be notified of the event with the (close) output.
+     */
+    dismissible: boolean;
+    /**
+     * If `true` the alert is visible to the user
+     */
+    visible: boolean;
+    /**
+     * Accessibility close button label
+     */
+    ariaCloseButtonLabel: string;
+    /**
+     * CSS classes to be applied on the widget main container
+     */
+    className: string;
+    /**
+     * Global template for the alert component
+     */
+    structure: SlotContent<AlertContext>;
+    /**
+     * Template for the alert content
+     */
+    children: SlotContent<AlertContext>;
+    /**
+     * Type of the alert, following bootstrap types.
+     */
+    type: BSContextualClass;
+}
+export type AlertWidget = Widget<AlertProps, AlertState, AlertApi, object, AlertDirectives>;
+export interface AlertApi {
+    /**
+     * Triggers alert closing programmatically (same as clicking on the close button (×)).
+     */
+    close(): void;
+    /**
+     * Triggers the alert to be displayed for the user.
+     */
+    open(): void;
+}
+export interface AlertDirectives {
+    /**
+     * the transition directive, piloting what is the visual effect of going from hidden to visible
+     */
+    transitionDirective: Directive;
+}

package/components/alert/alert.gen.js

@@ -0,0 +1 @@
+export {};

package/components/alert/alert.js

@@ -1,4 +1,3 @@
-export * from '@agnos-ui/core-bootstrap/components/alert';
-import { createAlert as coreCreateAlert } from '@agnos-ui/core-bootstrap/components/alert';
-// factory
+import { createAlert as coreCreateAlert, getAlertDefaultConfig as coreGetAlertDefaultConfig } from '@agnos-ui/core-bootstrap/components/alert';
 export const createAlert = coreCreateAlert;
+export const getAlertDefaultConfig = coreGetAlertDefaultConfig;

package/components/modal/Modal.svelte

@@ -8,8 +8,8 @@ import { callWidgetFactory } from "../../config";
 import ModalDefaultHeader from "./ModalDefaultHeader.svelte";
 import ModalDefaultStructure from "./ModalDefaultStructure.svelte";
 const defaultConfig = {
-  slotStructure: ModalDefaultStructure,
-  slotHeader: ModalDefaultHeader
+  structure: ModalDefaultStructure,
+  header: ModalDefaultHeader
 };
 </script>
 
@@ -28,14 +28,12 @@ const widget = callWidgetFactory({
 });
 export const api = widget.api;
 const {
-  stores: { backdropHidden$, hidden$, slotStructure$ },
+  stores: { backdropHidden$, hidden$, structure$ },
   directives: { backdropDirective, backdropPortalDirective, modalDirective, modalPortalDirective },
   state$
 } = widget;
-$:
-  widget.patchChangedProps($$props);
-$:
-  slotContext = { widget: toSlotContextWidget(widget), state: $state$ };
+$: widget.patchChangedProps($$props);
+$: slotContext = { widget: toSlotContextWidget(widget), state: $state$ };
 </script>
 
 {#if !$backdropHidden$}
@@ -46,7 +44,7 @@ $:
 	<div use:__AgnosUISveltePreprocess__classDirective={"modal d-block"} use:modalPortalDirective use:modalDirective {...__AgnosUISveltePreprocess__BROWSER ? {} : __AgnosUISveltePreprocess__ssrAttributes(modalPortalDirective, modalDirective, [__AgnosUISveltePreprocess__classDirective, "modal d-block"])}>
 		<div class="modal-dialog {$state$.fullscreen ? 'modal-fullscreen' : ''}">
 			<div class="modal-content">
-				<Slot slotContent={$slotStructure$} props={slotContext} let:component let:props>
+				<Slot slotContent={$structure$} props={slotContext} let:component let:props>
 					<svelte:fragment slot="slot" let:props><slot name="structure" {...props} /></svelte:fragment>
 					<svelte:component this={component} {...props}>
 						<svelte:fragment let:state let:widget><slot {state} {widget} /></svelte:fragment>

package/components/modal/Modal.svelte.d.ts

@@ -1,4 +1,4 @@
-import { SvelteComponentTyped } from "svelte";
+import { SvelteComponent } from "svelte";
 import type { ModalProps, ModalSlots, ModalApi } from './modal';
 declare class __sveltets_Render<Data> {
     props(): {
@@ -7,12 +7,12 @@ declare class __sveltets_Render<Data> {
     events(): {} & {
         [evt: string]: CustomEvent<any>;
     };
-    slots(): ModalSlots<Data>;
+    slots(): ModalSlots;
 }
 export type ModalProps_<Data> = ReturnType<__sveltets_Render<Data>['props']>;
 export type ModalEvents<Data> = ReturnType<__sveltets_Render<Data>['events']>;
 export type ModalSlots_<Data> = ReturnType<__sveltets_Render<Data>['slots']>;
-export default class Modal<Data> extends SvelteComponentTyped<ModalProps_<Data>, ModalEvents<Data>, ModalSlots_<Data>> {
+export default class Modal<Data> extends SvelteComponent<ModalProps_<Data>, ModalEvents<Data>, ModalSlots_<Data>> {
     get api(): ModalApi<Data>;
 }
 export {};

package/components/modal/ModalDefaultHeader.svelte

@@ -4,12 +4,11 @@ import {BROWSER as __AgnosUISveltePreprocess__BROWSER} from 'esm-env';
 import { Slot } from "@agnos-ui/svelte-headless/slot";
 export let state;
 export let widget;
-$:
-  slotContext = { widget, state };
+$: slotContext = { widget, state };
 </script>
 
 <h5 class="modal-title">
-	<Slot slotContent={state.slotTitle} props={slotContext} let:component let:props>
+	<Slot slotContent={state.title} props={slotContext} let:component let:props>
 		<svelte:fragment slot="slot" let:props><slot name="title" {...props} /></svelte:fragment>
 		<svelte:component this={component} {...props}>
 			<svelte:fragment let:state let:widget><slot {state} {widget} /></svelte:fragment>

package/components/modal/ModalDefaultHeader.svelte.d.ts

@@ -1,15 +1,15 @@
-import { SvelteComponentTyped } from "svelte";
-import type { ModalContext, ModalSlots } from './modal';
+import { SvelteComponent } from "svelte";
+import type { ModalSlots } from './modal';
 declare class __sveltets_Render<Data> {
-    props(): ModalContext<Data>;
+    props(): WidgetSlotContext<Widget<import("./modal.gen").ModalProps<Data_1>, import("./modal.gen").ModalState<Data_1>, import("./modal.gen").ModalApi<Data_1>, import("./modal.gen").ModalActions, import("./modal.gen").ModalDirectives>>;
     events(): {} & {
         [evt: string]: CustomEvent<any>;
     };
-    slots(): ModalSlots<Data>;
+    slots(): ModalSlots;
 }
 export type ModalDefaultHeaderProps<Data> = ReturnType<__sveltets_Render<Data>['props']>;
 export type ModalDefaultHeaderEvents<Data> = ReturnType<__sveltets_Render<Data>['events']>;
 export type ModalDefaultHeaderSlots<Data> = ReturnType<__sveltets_Render<Data>['slots']>;
-export default class ModalDefaultHeader<Data> extends SvelteComponentTyped<ModalDefaultHeaderProps<Data>, ModalDefaultHeaderEvents<Data>, ModalDefaultHeaderSlots<Data>> {
+export default class ModalDefaultHeader<Data> extends SvelteComponent<ModalDefaultHeaderProps<Data>, ModalDefaultHeaderEvents<Data>, ModalDefaultHeaderSlots<Data>> {
 }
 export {};

package/components/modal/ModalDefaultStructure.svelte

@@ -1,13 +1,12 @@
 <script>import { Slot } from "@agnos-ui/svelte-headless/slot";
 export let state;
 export let widget;
-$:
-  slotContext = { widget, state };
+$: slotContext = { widget, state };
 </script>
 
-{#if state.slotTitle}
+{#if state.title}
 	<div class="modal-header">
-		<Slot slotContent={state.slotHeader} props={slotContext} let:component let:props>
+		<Slot slotContent={state.header} props={slotContext} let:component let:props>
 			<svelte:fragment slot="slot" let:props><slot name="header" {...props} /></svelte:fragment>
 			<svelte:component this={component} {...props}>
 				<svelte:fragment let:state let:widget><slot {state} {widget} /></svelte:fragment>
@@ -21,7 +20,7 @@ $:
 {/if}
 
 <div class="modal-body">
-	<Slot slotContent={state.slotDefault} props={slotContext} let:component let:props>
+	<Slot slotContent={state.children} props={slotContext} let:component let:props>
 		<svelte:fragment slot="slot" let:props><slot {...props} /></svelte:fragment>
 		<svelte:component this={component} {...props}>
 			<svelte:fragment let:state let:widget><slot {state} {widget} /></svelte:fragment>
@@ -32,9 +31,9 @@ $:
 		</svelte:component>
 	</Slot>
 </div>
-{#if state.slotFooter}
+{#if state.footer}
 	<div class="modal-footer">
-		<Slot slotContent={state.slotFooter} props={slotContext} let:component let:props>
+		<Slot slotContent={state.footer} props={slotContext} let:component let:props>
 			<svelte:fragment slot="slot" let:props><slot name="footer" {...props} /></svelte:fragment>
 			<svelte:component this={component} {...props}>
 				<svelte:fragment let:state let:widget><slot {state} {widget} /></svelte:fragment>

package/components/modal/ModalDefaultStructure.svelte.d.ts

@@ -1,15 +1,15 @@
-import { SvelteComponentTyped } from "svelte";
-import type { ModalContext, ModalSlots } from './modal';
+import { SvelteComponent } from "svelte";
+import type { ModalSlots } from './modal';
 declare class __sveltets_Render<Data> {
-    props(): ModalContext<Data>;
+    props(): WidgetSlotContext<Widget<import("./modal.gen").ModalProps<Data_1>, import("./modal.gen").ModalState<Data_1>, import("./modal.gen").ModalApi<Data_1>, import("./modal.gen").ModalActions, import("./modal.gen").ModalDirectives>>;
     events(): {} & {
         [evt: string]: CustomEvent<any>;
     };
-    slots(): ModalSlots<Data>;
+    slots(): ModalSlots;
 }
 export type ModalDefaultStructureProps<Data> = ReturnType<__sveltets_Render<Data>['props']>;
 export type ModalDefaultStructureEvents<Data> = ReturnType<__sveltets_Render<Data>['events']>;
 export type ModalDefaultStructureSlots<Data> = ReturnType<__sveltets_Render<Data>['slots']>;
-export default class ModalDefaultStructure<Data> extends SvelteComponentTyped<ModalDefaultStructureProps<Data>, ModalDefaultStructureEvents<Data>, ModalDefaultStructureSlots<Data>> {
+export default class ModalDefaultStructure<Data> extends SvelteComponent<ModalDefaultStructureProps<Data>, ModalDefaultStructureEvents<Data>, ModalDefaultStructureSlots<Data>> {
 }
 export {};

package/components/modal/modal.d.ts

@@ -1,16 +1,8 @@
-export * from '@agnos-ui/core-bootstrap/components/modal';
-import type { AdaptSlotContentProps, AdaptWidgetSlots, WidgetPropsSlots, PropsConfig, WidgetProps, WidgetState, PropType } from '@agnos-ui/svelte-headless/types';
-import type { ModalWidget as CoreWidget, ModalContext as CoreContext } from '@agnos-ui/core-bootstrap/components/modal';
-export interface ModalWidget<Data> extends AdaptWidgetSlots<CoreWidget<Data>> {
-}
-export interface ModalProps<Data> extends WidgetProps<ModalWidget<Data>> {
-}
-export interface ModalState<Data> extends WidgetState<ModalWidget<Data>> {
-}
-export interface ModalApi<Data> extends PropType<ModalWidget<Data>, 'api'> {
-}
-export interface ModalSlots<Data> extends WidgetPropsSlots<ModalProps<Data>> {
-}
-export interface ModalContext<Data> extends AdaptSlotContentProps<CoreContext<Data>> {
-}
+import type { WidgetPropsSlots, PropsConfig } from '@agnos-ui/svelte-headless/types';
+import type { ModalProps, ModalWidget } from './modal.gen';
+export type * from './modal.gen';
 export declare const createModal: <Data>(propsConfig?: PropsConfig<ModalProps<Data>>) => ModalWidget<Data>;
+export { modalCloseButtonClick, modalOutsideClick } from '@agnos-ui/core-bootstrap/components/modal';
+export declare const getModalDefaultConfig: () => ModalProps<any>;
+export interface ModalSlots extends WidgetPropsSlots<ModalProps<any>> {
+}

package/components/modal/modal.gen.d.ts

@@ -0,0 +1,239 @@
+import type { WidgetSlotContext, SlotContent, Widget, Directive } from '@agnos-ui/svelte-headless/types';
+import type { TransitionFn } from '@agnos-ui/svelte-headless/services/transitions/baseTransitions';
+export type ModalContext<Data> = WidgetSlotContext<ModalWidget<Data>>;
+export interface ModalState<Data> {
+    /**
+     * Whether the backdrop is fully hidden. This can be true either because {@link ModalProps.backdropbackdrop} is false or
+     * because {@link ModalCommonPropsAndState.visiblevisible} is false and there is no current transition.
+     */
+    backdropHidden: boolean;
+    /**
+     * Whether the modal is fully hidden.
+     */
+    hidden: boolean;
+    /**
+     * Whether there is an active transition to either display or hide the modal.
+     */
+    transitioning: boolean;
+    /**
+     * DOM element of the modal.
+     */
+    modalElement: HTMLElement | null;
+    /**
+     * Value of the aria-label attribute to put on the close button.
+     */
+    ariaCloseButtonLabel: string;
+    /**
+     * Classes to add on the backdrop DOM element.
+     */
+    backdropClass: string;
+    /**
+     * Whether to display the close button.
+     */
+    closeButton: boolean;
+    /**
+     * Which element should contain the modal and backdrop DOM elements.
+     * If it is not null, the modal and backdrop DOM elements are moved to the specified container.
+     * Otherwise, they stay where the widget is located.
+     */
+    container: HTMLElement | null;
+    /**
+     * Whether the modal should be visible when the transition is completed.
+     */
+    visible: boolean;
+    /**
+     * CSS classes to be applied on the widget main container
+     */
+    className: string;
+    /**
+     * Data to use in content slots
+     */
+    contentData: Data;
+    /**
+     * Body of the modal.
+     */
+    children: SlotContent<ModalContext<Data>>;
+    /**
+     * Footer of the modal.
+     */
+    footer: SlotContent<ModalContext<Data>>;
+    /**
+     * Header of the modal. The default header includes {@link ModalCommonPropsAndState.title title}.
+     */
+    header: SlotContent<ModalContext<Data>>;
+    /**
+     * Structure of the modal.
+     * The default structure uses {@link ModalCommonPropsAndState.header header}, {@link ModalCommonPropsAndState.children children} and {@link ModalCommonPropsAndState.footer footer}.
+     */
+    structure: SlotContent<ModalContext<Data>>;
+    /**
+     * Title of the modal.
+     */
+    title: SlotContent<ModalContext<Data>>;
+    /**
+     * Option to create a fullscreen modal, according to the bootstrap documentation.
+     */
+    fullscreen: boolean;
+}
+export interface ModalProps<Data> {
+    /**
+     * Whether the modal and its backdrop (if present) should be animated when shown or hidden.
+     */
+    animated: boolean;
+    /**
+     * Whether a backdrop should be created behind the modal.
+     */
+    backdrop: boolean;
+    /**
+     * The transition to use for the backdrop behind the modal (if present).
+     */
+    backdropTransition: TransitionFn;
+    /**
+     * Whether the modal should be closed when clicking on the viewport outside the modal.
+     */
+    closeOnOutsideClick: boolean;
+    /**
+     * The transition to use for the modal.
+     */
+    modalTransition: TransitionFn;
+    /**
+     * Event to be triggered when the modal is about to be closed (i.e. the {@link ModalApi.closeclose} method was called).
+     */
+    onBeforeClose: (event: ModalBeforeCloseEvent) => void;
+    /**
+     * Event to be triggered when the visible property changes.
+     */
+    onVisibleChange: (visible: boolean) => void;
+    /**
+     * Event to be triggered when the transition is completed and the modal is not visible.
+     */
+    onHidden: () => void;
+    /**
+     * Event to be triggered when the transition is completed and the modal is visible.
+     */
+    onShown: () => void;
+    /**
+     * Value of the aria-label attribute to put on the close button.
+     */
+    ariaCloseButtonLabel: string;
+    /**
+     * Classes to add on the backdrop DOM element.
+     */
+    backdropClass: string;
+    /**
+     * Whether to display the close button.
+     */
+    closeButton: boolean;
+    /**
+     * Which element should contain the modal and backdrop DOM elements.
+     * If it is not null, the modal and backdrop DOM elements are moved to the specified container.
+     * Otherwise, they stay where the widget is located.
+     */
+    container: HTMLElement | null;
+    /**
+     * Whether the modal should be visible when the transition is completed.
+     */
+    visible: boolean;
+    /**
+     * CSS classes to be applied on the widget main container
+     */
+    className: string;
+    /**
+     * Data to use in content slots
+     */
+    contentData: Data;
+    /**
+     * Body of the modal.
+     */
+    children: SlotContent<ModalContext<Data>>;
+    /**
+     * Footer of the modal.
+     */
+    footer: SlotContent<ModalContext<Data>>;
+    /**
+     * Header of the modal. The default header includes {@link ModalCommonPropsAndState.title title}.
+     */
+    header: SlotContent<ModalContext<Data>>;
+    /**
+     * Structure of the modal.
+     * The default structure uses {@link ModalCommonPropsAndState.header header}, {@link ModalCommonPropsAndState.children children} and {@link ModalCommonPropsAndState.footer footer}.
+     */
+    structure: SlotContent<ModalContext<Data>>;
+    /**
+     * Title of the modal.
+     */
+    title: SlotContent<ModalContext<Data>>;
+    /**
+     * Option to create a fullscreen modal, according to the bootstrap documentation.
+     */
+    fullscreen: boolean;
+}
+export interface ModalApi<Data> {
+    /**
+     * Method to change some modal properties.
+     */
+    patch: ModalWidget<Data>['patch'];
+    /**
+     * Closes the modal with the given result.
+     */
+    close(result?: any): void;
+    /**
+     * Opens the modal and returns a promise that is resolved when the modal is closed.
+     * The resolved value is the result passed to the {@link ModalApi.closeclose} method and possibly changed by the
+     * {@link ModalProps.onBeforeCloseonBeforeClose} event handler
+     */
+    open(): Promise<any>;
+}
+export type ModalWidget<Data> = Widget<ModalProps<Data>, ModalState<Data>, ModalApi<Data>, ModalActions, ModalDirectives>;
+export interface ModalBeforeCloseEvent {
+    /**
+     * Result of the modal, which is the value passed to the {@link ModalApi.closeclose} method
+     * and later resolved by the promise returned by the {@link ModalApi.openopen} method.
+     * If needed, it can be changed from the {@link ModalProps.onBeforeCloseonBeforeClose} event handler.
+     */
+    result: any;
+    /**
+     * Whether to cancel the close of the modal.
+     * It can be changed from the {@link ModalProps.onBeforeCloseonBeforeClose} event handler.
+     */
+    cancel: boolean;
+}
+export interface ModalActions {
+    /**
+     * Action to be called when the user clicks on the close button. It closes the modal with the {@link modalCloseButtonClick} result.
+     */
+    closeButtonClick(event: Pick<MouseEvent, never>): void;
+    /**
+     * Action to be called when the user clicks on the modal DOM element (which is supposed to have the size of the full viewport).
+     * If the click is not done on a descendant of the modal DOM element, it is considered to be done outside the modal
+     * and, depending on the value of the {@link ModalProps.closeOnOutsideClickcloseOnOutsideClick} prop, the modal is or isn't closed
+     * (with the {@link modalOutsideClick} result).
+     */
+    modalClick(event: Pick<MouseEvent, 'target' | 'currentTarget'>): void;
+}
+export interface ModalDirectives {
+    /**
+     * Directive to put on the modal DOM element.
+     */
+    modalDirective: Directive;
+    /**
+     * Directive to put on the backdrop DOM element.
+     */
+    backdropDirective: Directive;
+    /**
+     * Portal directive to put on the modal DOM element.
+     */
+    modalPortalDirective: Directive;
+    /**
+     * Portal directive to put on the backdrop DOM element.
+     */
+    backdropPortalDirective: Directive;
+    /**
+     * Directive that adds all the necessary attributes to the close button
+     */
+    closeButtonDirective: Directive;
+    /**
+     * Directive to apply to the dialog element when using the native [HTMLDialogElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLDialogElement)
+     */
+    dialogDirective: Directive;
+}

package/components/modal/modal.gen.js

@@ -0,0 +1 @@
+export {};

package/components/modal/modal.js

@@ -1,4 +1,4 @@
-export * from '@agnos-ui/core-bootstrap/components/modal';
-import { createModal as coreCreateModal } from '@agnos-ui/core-bootstrap/components/modal';
-// factory
+import { createModal as coreCreateModal, getModalDefaultConfig as coreGetModalDefaultConfig } from '@agnos-ui/core-bootstrap/components/modal';
 export const createModal = coreCreateModal;
+export { modalCloseButtonClick, modalOutsideClick } from '@agnos-ui/core-bootstrap/components/modal';
+export const getModalDefaultConfig = coreGetModalDefaultConfig;