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

package/components/accordion/Accordion.svelte

@@ -3,25 +3,19 @@ import {ssrAttributes as __AgnosUISveltePreprocess__ssrAttributes, classDirectiv
 import {BROWSER as __AgnosUISveltePreprocess__BROWSER} from 'esm-env';
 import { callWidgetFactory } from "../../config";
 import { createAccordion, setAccordionApi } from "./accordion";
-export let itemVisible = void 0;
 const widget = callWidgetFactory({
   factory: createAccordion,
   widgetName: "accordion",
   $$slots,
   $$props,
-  events: {
-    onItemVisibleChange: (event) => {
-      itemVisible = event;
-    }
-  }
+  events: {}
 });
 export const api = widget.api;
 const {
   directives: { accordionDirective }
 } = widget;
 setAccordionApi(widget.api);
-$:
-  widget.patchChangedProps($$props);
+$: widget.patchChangedProps($$props);
 </script>
 
 <div use:__AgnosUISveltePreprocess__classDirective={"accordion"} use:accordionDirective {...__AgnosUISveltePreprocess__BROWSER ? {} : __AgnosUISveltePreprocess__ssrAttributes(accordionDirective, [__AgnosUISveltePreprocess__classDirective, "accordion"])}>

package/components/accordion/Accordion.svelte.d.ts

@@ -1,4 +1,4 @@
-import { SvelteComponentTyped } from "svelte";
+import { SvelteComponent } from "svelte";
 import type { AccordionApi, AccordionProps, AccordionSlots } from './accordion';
 declare const __propDef: {
     props: {
@@ -10,12 +10,14 @@ declare const __propDef: {
     slots: {
         default: Record<string, never>;
     } & AccordionSlots;
+    exports?: {} | undefined;
+    bindings?: string | undefined;
 };
 type AccordionProps_ = typeof __propDef.props;
 export { AccordionProps_ as AccordionProps };
 export type AccordionEvents = typeof __propDef.events;
 type AccordionSlots_ = typeof __propDef.slots;
 export { AccordionSlots_ as AccordionSlots };
-export default class Accordion extends SvelteComponentTyped<AccordionProps_, AccordionEvents, AccordionSlots_> {
+export default class Accordion extends SvelteComponent<AccordionProps_, AccordionEvents, AccordionSlots_> {
     get api(): AccordionApi;
 }

package/components/accordion/Item.svelte

@@ -8,46 +8,44 @@ import { onMount } from "svelte";
 import ItemDefaultStructure from "./ItemDefaultStructure.svelte";
 import { getAccordionApi } from "./accordion";
 const defaultConfig = {
-  slotItemStructure: ItemDefaultStructure
+  structure: ItemDefaultStructure
 };
 </script>
 
 <script>const accordionApi = getAccordionApi();
 const { registerItem } = accordionApi;
-export let itemVisible = void 0;
+export let visible = void 0;
 const widget = callWidgetFactory({
   factory: registerItem,
   $$slots,
   $$props,
   defaultConfig,
   events: {
-    onItemVisibleChange: (event) => {
-      itemVisible = event;
+    onVisibleChange: (event) => {
+      visible = event;
     }
   }
 });
 const {
-  stores: { slotItemStructure$ },
-  directives: { accordionItemDirective },
+  stores: { structure$ },
+  directives: { itemDirective },
   state$
 } = widget;
 export const api = widget.api;
-$:
-  widget.patchChangedProps($$props);
-$:
-  slotContext = { widget: toSlotContextWidget(widget), state: $state$ };
+$: widget.patchChangedProps($$props);
+$: slotContext = { widget: toSlotContextWidget(widget), state: $state$ };
 onMount(() => {
   widget.api.initDone();
 });
 </script>
 
-<div use:__AgnosUISveltePreprocess__classDirective={"accordion-item"} use:accordionItemDirective {...__AgnosUISveltePreprocess__BROWSER ? {} : __AgnosUISveltePreprocess__ssrAttributes(accordionItemDirective, [__AgnosUISveltePreprocess__classDirective, "accordion-item"])}>
-	<Slot slotContent={$slotItemStructure$} props={slotContext} let:component let:props>
-		<svelte:fragment slot="slot" let:props><slot name="itemStructure" {...props} /></svelte:fragment>
+<div use:__AgnosUISveltePreprocess__classDirective={"accordion-item"} use:itemDirective {...__AgnosUISveltePreprocess__BROWSER ? {} : __AgnosUISveltePreprocess__ssrAttributes(itemDirective, [__AgnosUISveltePreprocess__classDirective, "accordion-item"])}>
+	<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 slot="itemBody" let:state let:widget><slot name="itemBody" {state} {widget} /></svelte:fragment>
-			<svelte:fragment slot="itemHeader" let:state let:widget><slot name="itemHeader" {state} {widget} /></svelte:fragment>
-			<svelte:fragment slot="itemStructure" let:state let:widget><slot name="itemStructure" {state} {widget} /></svelte:fragment>
+			<svelte:fragment let:state let:widget><slot {state} {widget} /></svelte:fragment>
+			<svelte:fragment slot="header" let:state let:widget><slot name="header" {state} {widget} /></svelte:fragment>
+			<svelte:fragment slot="structure" let:state let:widget><slot name="structure" {state} {widget} /></svelte:fragment>
 		</svelte:component>
 	</Slot>
 </div>

package/components/accordion/Item.svelte.d.ts

@@ -1,5 +1,5 @@
-import { SvelteComponentTyped } from "svelte";
-import type { AccordionItemApi, AccordionItemProps, AccordionSlots } from './accordion';
+import { SvelteComponent } from "svelte";
+import type { AccordionItemApi, AccordionItemProps, AccordionItemSlots } from './accordion';
 declare const __propDef: {
     props: {
         api?: AccordionItemApi | undefined;
@@ -7,12 +7,14 @@ declare const __propDef: {
     events: {
         [evt: string]: CustomEvent<any>;
     };
-    slots: AccordionSlots;
+    slots: AccordionItemSlots;
+    exports?: {} | undefined;
+    bindings?: string | undefined;
 };
 export type ItemProps = typeof __propDef.props;
 export type ItemEvents = typeof __propDef.events;
 export type ItemSlots = typeof __propDef.slots;
-export default class Item extends SvelteComponentTyped<ItemProps, ItemEvents, ItemSlots> {
+export default class Item extends SvelteComponent<ItemProps, ItemEvents, ItemSlots> {
     get api(): AccordionItemApi;
 }
 export {};

package/components/accordion/ItemDefaultStructure.svelte

@@ -5,20 +5,18 @@ import { Slot } from "@agnos-ui/svelte-headless/slot";
 export let state;
 export let widget;
 const re = new RegExp("^h[1-6]$");
-$:
-  slotContext = { widget, state };
-$:
-  headingTag = re.test(state.itemHeadingTag) ? state.itemHeadingTag : "h2";
+$: slotContext = { widget, state };
+$: headingTag = re.test(state.headingTag) ? state.headingTag : "h2";
 </script>
 
 <svelte:element this={headingTag} use:__AgnosUISveltePreprocess__classDirective={"accordion-header"} use:slotContext.widget.directives.headerDirective {...__AgnosUISveltePreprocess__BROWSER ? {} : __AgnosUISveltePreprocess__ssrAttributes(slotContext.widget.directives.headerDirective, [__AgnosUISveltePreprocess__classDirective, "accordion-header"])}>
 	<button use:slotContext.widget.directives.buttonDirective use:__AgnosUISveltePreprocess__classDirective={"accordion-button"} {...__AgnosUISveltePreprocess__BROWSER ? {} : __AgnosUISveltePreprocess__ssrAttributes(slotContext.widget.directives.buttonDirective, [__AgnosUISveltePreprocess__classDirective, "accordion-button"])}>
-		<Slot slotContent={state.slotItemHeader} props={slotContext} let:component let:props>
-			<svelte:fragment slot="slot" let:props><slot name="itemHeader" {...props} /></svelte:fragment>
+		<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 slot="itemBody" let:state let:widget><slot name="itemBody" {state} {widget} /></svelte:fragment>
-				<svelte:fragment slot="itemHeader" let:state let:widget><slot name="itemHeader" {state} {widget} /></svelte:fragment>
-				<svelte:fragment slot="itemStructure" let:state let:widget><slot name="itemStructure" {state} {widget} /></svelte:fragment>
+				<svelte:fragment let:state let:widget><slot {state} {widget} /></svelte:fragment>
+				<svelte:fragment slot="header" let:state let:widget><slot name="header" {state} {widget} /></svelte:fragment>
+				<svelte:fragment slot="structure" let:state let:widget><slot name="structure" {state} {widget} /></svelte:fragment>
 			</svelte:component>
 		</Slot>
 	</button>
@@ -26,12 +24,12 @@ $:
 {#if state.shouldBeInDOM}
 	<div use:__AgnosUISveltePreprocess__classDirective={"accordion-collapse"} use:widget.directives.bodyContainerDirective {...__AgnosUISveltePreprocess__BROWSER ? {} : __AgnosUISveltePreprocess__ssrAttributes(widget.directives.bodyContainerDirective, [__AgnosUISveltePreprocess__classDirective, "accordion-collapse"])}>
 		<div use:__AgnosUISveltePreprocess__classDirective={"accordion-body"} use:widget.directives.bodyDirective {...__AgnosUISveltePreprocess__BROWSER ? {} : __AgnosUISveltePreprocess__ssrAttributes(widget.directives.bodyDirective, [__AgnosUISveltePreprocess__classDirective, "accordion-body"])}>
-			<Slot slotContent={state.slotItemBody} props={slotContext} let:component let:props>
-				<svelte:fragment slot="slot" let:props><slot name="itemBody" {...props} /></svelte:fragment>
+			<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 slot="itemBody" let:state let:widget><slot name="itemBody" {state} {widget} /></svelte:fragment>
-					<svelte:fragment slot="itemHeader" let:state let:widget><slot name="itemHeader" {state} {widget} /></svelte:fragment>
-					<svelte:fragment slot="itemStructure" let:state let:widget><slot name="itemStructure" {state} {widget} /></svelte:fragment>
+					<svelte:fragment let:state let:widget><slot {state} {widget} /></svelte:fragment>
+					<svelte:fragment slot="header" let:state let:widget><slot name="header" {state} {widget} /></svelte:fragment>
+					<svelte:fragment slot="structure" let:state let:widget><slot name="structure" {state} {widget} /></svelte:fragment>
 				</svelte:component>
 			</Slot>
 		</div>

package/components/accordion/ItemDefaultStructure.svelte.d.ts

@@ -1,15 +1,17 @@
-import { SvelteComponentTyped } from "svelte";
-import type { AccordionItemContext, AccordionSlots } from './accordion';
+import { SvelteComponent } from "svelte";
+import type { AccordionItemSlots } from './accordion';
 declare const __propDef: {
-    props: AccordionItemContext;
+    props: WidgetSlotContext<Widget<import("./accordion.gen").AccordionItemProps, import("./accordion.gen").AccordionItemState, import("./accordion.gen").AccordionItemApi, import("./accordion.gen").AccordionItemActions, import("./accordion.gen").AccordionItemDirectives>>;
     events: {
         [evt: string]: CustomEvent<any>;
     };
-    slots: AccordionSlots;
+    slots: AccordionItemSlots;
+    exports?: {} | undefined;
+    bindings?: string | undefined;
 };
 export type ItemDefaultStructureProps = typeof __propDef.props;
 export type ItemDefaultStructureEvents = typeof __propDef.events;
 export type ItemDefaultStructureSlots = typeof __propDef.slots;
-export default class ItemDefaultStructure extends SvelteComponentTyped<ItemDefaultStructureProps, ItemDefaultStructureEvents, ItemDefaultStructureSlots> {
+export default class ItemDefaultStructure extends SvelteComponent<ItemDefaultStructureProps, ItemDefaultStructureEvents, ItemDefaultStructureSlots> {
 }
 export {};

package/components/accordion/accordion.d.ts

@@ -1,26 +1,12 @@
-export * from '@agnos-ui/core-bootstrap/components/accordion';
-import type { AdaptSlotContentProps, AdaptWidgetSlots, WidgetFactory, WidgetProps, WidgetState, WidgetPropsSlots, PropType } from '@agnos-ui/svelte-headless/types';
-import type { AccordionWidget as CoreWidget, AccordionItemWidget as CoreItemWidget, AccordionItemContext as CoreItemContext } from '@agnos-ui/core-bootstrap/components/accordion';
-export interface AccordionWidget extends AdaptWidgetSlots<CoreWidget> {
-}
-export interface AccordionProps extends WidgetProps<AccordionWidget> {
-}
-export interface AccordionState extends WidgetState<AccordionWidget> {
-}
-export interface AccordionApi extends PropType<AccordionWidget, 'api'> {
-}
-export interface AccordionItemWidget extends AdaptWidgetSlots<CoreItemWidget> {
-}
-export interface AccordionItemProps extends WidgetProps<AccordionItemWidget> {
-}
-export interface AccordionItemState extends WidgetState<AccordionItemWidget> {
-}
-export interface AccordionItemApi extends PropType<AccordionItemWidget, 'api'> {
-}
+import type { WidgetFactory, WidgetPropsSlots } from '@agnos-ui/svelte-headless/types';
+import type { AccordionWidget, AccordionApi, AccordionProps, AccordionItemProps, AccordionItemWidget } from './accordion.gen';
+export type * from './accordion.gen';
+export declare const createAccordion: WidgetFactory<AccordionWidget>;
+export declare const getAccordionDefaultConfig: () => AccordionProps;
+export declare const createAccordionItem: WidgetFactory<AccordionItemWidget>;
 export interface AccordionSlots extends WidgetPropsSlots<AccordionProps> {
 }
-export interface AccordionItemContext extends AdaptSlotContentProps<CoreItemContext> {
+export interface AccordionItemSlots extends WidgetPropsSlots<AccordionItemProps> {
 }
-export declare const createAccordion: WidgetFactory<AccordionWidget>;
 export declare function setAccordionApi(accordionApi: AccordionApi): void;
 export declare function getAccordionApi(): AccordionApi;

package/components/accordion/accordion.gen.d.ts

@@ -0,0 +1,343 @@
+import type { WidgetSlotContext, SlotContent, Widget, PropsConfig, Directive } from '@agnos-ui/svelte-headless/types';
+import type { TransitionFn } from '@agnos-ui/svelte-headless/services/transitions/baseTransitions';
+export type AccordionItemContext = WidgetSlotContext<AccordionItemWidget>;
+export interface AccordionState {
+    /**
+     * Array containing all the accordion-items contained in the accordion.
+     */
+    itemWidgets: AccordionItemWidget[];
+    /**
+     * CSS classes to be applied on the widget main container
+     */
+    className: string;
+    /**
+     * Structure of the accordion-item. The default item structure is: accordion-item
+     * contains accordion header and accordion-item body container; the accordion header contains the accordion button
+     * (that contains `header`), while the accordion-item body container contains the accordion body (that contains `children`).
+     * The itemTransition is applied on this element.
+     *
+     * It is a prop of the accordion-item.
+     */
+    itemStructure: SlotContent<AccordionItemContext>;
+}
+export interface AccordionProps {
+    /**
+     * If `true`, only one accordion-item at the time can stay open.
+     */
+    closeOthers: boolean;
+    /**
+     * An event fired when an item is shown.
+     *
+     * Event payload is the id of the item.
+     */
+    onItemShown: (itemId: string) => void;
+    /**
+     * An event fired when an item is hidden.
+     *
+     * Event payload is the id of the item.
+     */
+    onItemHidden: (itemId: string) => void;
+    /**
+     * If `true`, the accordion-item body container will be removed from the DOM when the accordion-item is collapsed. It will be just hidden otherwise.
+     */
+    itemDestroyOnHide: boolean;
+    /**
+     * If `true`, accordion-item will be animated.
+     */
+    itemAnimated: boolean;
+    /**
+     * The transition to use for the accordion-item body-container when the accordion-item is toggled.
+     */
+    itemTransition: TransitionFn;
+    /**
+     * CSS classes to add on the accordion-item DOM element.
+     */
+    itemClassName: string;
+    /**
+     * CSS classes to add on the accordion-item header DOM element.
+     */
+    itemHeaderClassName: string;
+    /**
+     * CSS classes to add on the accordion-item toggle button DOM element.
+     */
+    itemButtonClassName: string;
+    /**
+     * CSS classes to add on the accordion-item body container DOM element.
+     * The accordion-item body container is the DOM element on what the itemTransition is applied.
+     */
+    itemBodyContainerClassName: string;
+    /**
+     * CSS classes to add on the accordion-item body DOM element.
+     */
+    itemBodyClassName: string;
+    /**
+     * The html tag to use for the accordion-item-header.
+     */
+    itemHeadingTag: string;
+    /**
+     * CSS classes to be applied on the widget main container
+     */
+    className: string;
+    /**
+     * Structure of the accordion-item. The default item structure is: accordion-item
+     * contains accordion header and accordion-item body container; the accordion header contains the accordion button
+     * (that contains `header`), while the accordion-item body container contains the accordion body (that contains `children`).
+     * The itemTransition is applied on this element.
+     *
+     * It is a prop of the accordion-item.
+     */
+    itemStructure: SlotContent<AccordionItemContext>;
+}
+export type AccordionWidget = Widget<AccordionProps, AccordionState, AccordionApi, object, AccordionDirectives>;
+export interface AccordionItemState {
+    /**
+     * If `true` the content of the accordion-item collapse should be in DOM. Its value depends on the
+     * value of the `visible` and `destroyOnHide`.
+     */
+    shouldBeInDOM: boolean;
+    /**
+     * If `true`, the accordion-item will be visible (expanded). Otherwise, it will be hidden (collapsed).
+     */
+    visible: boolean;
+    /**
+     * If `true`, the accordion-item will be disabled.
+     * It will not react to user's clicks, but still will be possible to toggle programmatically.
+     */
+    disabled: boolean;
+    /**
+     * The id of the accordion-item. It can be used for controlling the accordion-item via the accordion api.
+     */
+    id: string;
+    /**
+     * CSS classes to add on the accordion-item header DOM element.
+     */
+    headerClassName: string;
+    /**
+     * CSS classes to add on the accordion-item collapse DOM element.
+     */
+    buttonClassName: string;
+    /**
+     * CSS classes to add on the accordion-item body container DOM element.
+     * The accordion-item body container is the DOM element on what the itemTransition is applied.
+     */
+    bodyContainerClassName: string;
+    /**
+     * CSS classes to add on the accordion-item body DOM element.
+     */
+    bodyClassName: string;
+    /**
+     * The html tag to use for the accordion-item-header.
+     */
+    headingTag: string;
+    /**
+     * CSS classes to be applied on the widget main container
+     */
+    className: string;
+    /**
+     * Structure of the accordion-item. The default item structure is: accordion-item
+     * contains accordion header and accordion-item body container; the accordion header contains the accordion button
+     * (that contains `header`), while the accordion-item body container contains the accordion body (that contains `children`).
+     * The itemTransition is applied on this element.
+     *
+     * It is a prop of the accordion-item.
+     */
+    structure: SlotContent<AccordionItemContext>;
+    /**
+     * Content present in the accordion body.
+     *
+     * It is a prop of the accordion-item.
+     */
+    children: SlotContent<AccordionItemContext>;
+    /**
+     * Content present in the accordion button inside the accordion header.
+     *
+     * It is a prop of the accordion-item.
+     */
+    header: SlotContent<AccordionItemContext>;
+}
+export interface AccordionItemProps {
+    /**
+     * If `true`, accordion-item will be animated.
+     */
+    animated: boolean;
+    /**
+     * The transition to use for the accordion-item body-container when the accordion-item is toggled.
+     */
+    transition: TransitionFn;
+    /**
+     * If `true`, the accordion-item body container will be removed from the DOM when the accordion-item is collapsed. It will be just hidden otherwise.
+     */
+    destroyOnHide: boolean;
+    /**
+     * An event fired when an item is shown.
+     */
+    onShown: () => void;
+    /**
+     * An event fired when an item is hidden.
+     */
+    onHidden: () => void;
+    /**
+     * An event fired when the `visible` value changes.
+     *
+     * Event payload is the new value of visible.
+     */
+    onVisibleChange: (visible: boolean) => void;
+    /**
+     * If `true`, the accordion-item will be visible (expanded). Otherwise, it will be hidden (collapsed).
+     */
+    visible: boolean;
+    /**
+     * If `true`, the accordion-item will be disabled.
+     * It will not react to user's clicks, but still will be possible to toggle programmatically.
+     */
+    disabled: boolean;
+    /**
+     * The id of the accordion-item. It can be used for controlling the accordion-item via the accordion api.
+     */
+    id: string;
+    /**
+     * CSS classes to add on the accordion-item header DOM element.
+     */
+    headerClassName: string;
+    /**
+     * CSS classes to add on the accordion-item collapse DOM element.
+     */
+    buttonClassName: string;
+    /**
+     * CSS classes to add on the accordion-item body container DOM element.
+     * The accordion-item body container is the DOM element on what the itemTransition is applied.
+     */
+    bodyContainerClassName: string;
+    /**
+     * CSS classes to add on the accordion-item body DOM element.
+     */
+    bodyClassName: string;
+    /**
+     * The html tag to use for the accordion-item-header.
+     */
+    headingTag: string;
+    /**
+     * CSS classes to be applied on the widget main container
+     */
+    className: string;
+    /**
+     * Structure of the accordion-item. The default item structure is: accordion-item
+     * contains accordion header and accordion-item body container; the accordion header contains the accordion button
+     * (that contains `header`), while the accordion-item body container contains the accordion body (that contains `children`).
+     * The itemTransition is applied on this element.
+     *
+     * It is a prop of the accordion-item.
+     */
+    structure: SlotContent<AccordionItemContext>;
+    /**
+     * Content present in the accordion body.
+     *
+     * It is a prop of the accordion-item.
+     */
+    children: SlotContent<AccordionItemContext>;
+    /**
+     * Content present in the accordion button inside the accordion header.
+     *
+     * It is a prop of the accordion-item.
+     */
+    header: SlotContent<AccordionItemContext>;
+}
+export type AccordionItemWidget = Widget<AccordionItemProps, AccordionItemState, AccordionItemApi, AccordionItemActions, AccordionItemDirectives>;
+export interface AccordionApi {
+    /**
+     * Given the itemId, will expand the corresponding accordion-item.
+     *
+     * If the itemId is not valid, nothing will happen.
+     */
+    expand(itemId: string): void;
+    /**
+     * Given the itemId, will collapse the corresponding accordion-item.
+     *
+     * If the itemId is not valid, nothing will happen.
+     */
+    collapse(itemId: string): void;
+    /**
+     * Given the itemId, will toggle the corresponding accordion-item.
+     *
+     * If the itemId is not valid, nothing will happen.
+     */
+    toggle(itemId: string): void;
+    /**
+     * It will expand all the items in the accordion.
+     *
+     * If `closeOthers` is `true` it will expand only the last accordion-item.
+     */
+    expandAll(): void;
+    /**
+     * It will collapse all the accordion-items in the accordion.
+     */
+    collapseAll(): void;
+    /**
+     * Creates a new accordionItem.
+     */
+    registerItem(itemConfig?: PropsConfig<AccordionItemProps>): AccordionItemWidget;
+}
+export interface AccordionDirectives {
+    /**
+     * Directive to put on the accordion DOM element
+     */
+    accordionDirective: Directive;
+}
+export interface AccordionItemActions {
+    /**
+     * Action to be called when the user clicks on the accordion-item button. If the accordion-item is disabled nothing will happen.
+     */
+    click(): void;
+}
+export interface AccordionItemApi {
+    /**
+     * It will collapse the accordion-item.
+     */
+    collapse(): void;
+    /**
+     * It will expand the accordion-item.
+     */
+    expand(): void;
+    /**
+     * It will toggle the accordion-item.
+     */
+    toggle(): void;
+    /**
+     * Method to be called after the initialization to allow animations.
+     */
+    initDone(): void;
+}
+export interface AccordionItemDirectives {
+    /**
+     * Directive to use in special cases, if the accordion header does not use a button element to control the collapsing.
+     */
+    toggleDirective: Directive;
+    /**
+     * Directive to put on the button element that will control the collapsing of the accordion-item.
+     */
+    buttonDirective: Directive;
+    /**
+     * Directive to put on the accordion-item header that will contain the button element.
+     */
+    headerDirective: Directive;
+    /**
+     * Directive to put on the accordion-item body.
+     */
+    bodyDirective: Directive;
+    /**
+     * Directive to apply the itemTransition
+     */
+    transitionDirective: Directive;
+    /**
+     * Directive to apply aria attributes to the expanded body panel
+     */
+    bodyContainerAttrsDirective: Directive;
+    /**
+     * Directive to be put on the accordion-item body container. It will handle the animation.
+     */
+    bodyContainerDirective: Directive;
+    /**
+     * Directive to be put on the accordion-item. It will handle adding the accordion-item to the accordion.
+     */
+    itemDirective: Directive;
+}

package/components/accordion/accordion.gen.js

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

package/components/accordion/accordion.js

@@ -1,7 +1,7 @@
-export * from '@agnos-ui/core-bootstrap/components/accordion';
-import { createAccordion as coreCreateAccordion } from '@agnos-ui/core-bootstrap/components/accordion';
-// factory
+import { createAccordion as coreCreateAccordion, getAccordionDefaultConfig as coreGetAccordionDefaultConfig, createAccordionItem as coreCreateAccordionItem, } from '@agnos-ui/core-bootstrap/components/accordion';
 export const createAccordion = coreCreateAccordion;
+export const getAccordionDefaultConfig = coreGetAccordionDefaultConfig;
+export const createAccordionItem = coreCreateAccordionItem;
 // context
 import { getContext, setContext } from 'svelte';
 const contextInjectionKey = Symbol('accordion-api');

package/components/alert/Alert.svelte

@@ -6,7 +6,7 @@ import { createAlert } from "./alert";
 import { callWidgetFactory } from "../../config";
 import AlertDefaultStructure from "./AlertDefaultStructure.svelte";
 const defaultConfig = {
-  slotStructure: AlertDefaultStructure
+  structure: AlertDefaultStructure
 };
 </script>
 
@@ -25,14 +25,12 @@ const defaultConfig = {
 export let visible = void 0;
 export const api = widget.api;
 const {
-  stores: { slotStructure$, hidden$ },
+  stores: { structure$, hidden$ },
   directives: { transitionDirective },
   state$
 } = widget;
-$:
-  widget.patchChangedProps($$props);
-$:
-  slotContext = { widget, state: $state$ };
+$: widget.patchChangedProps($$props);
+$: slotContext = { widget, state: $state$ };
 </script>
 
 {#if !$hidden$}
@@ -41,7 +39,7 @@ $:
 		use:__AgnosUISveltePreprocess__classDirective={"au-alert alert alert-"+($state$.type)+" "+($state$.className)+" "+($state$.dismissible ? 'alert-dismissible' : '')}
 		use:transitionDirective {...__AgnosUISveltePreprocess__BROWSER ? {} : __AgnosUISveltePreprocess__ssrAttributes(transitionDirective, [__AgnosUISveltePreprocess__classDirective, "au-alert alert alert-"+($state$.type)+" "+($state$.className)+" "+($state$.dismissible ? 'alert-dismissible' : '')])}
 	>
-		<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/alert/Alert.svelte.d.ts

@@ -1,4 +1,4 @@
-import { SvelteComponentTyped } from "svelte";
+import { SvelteComponent } from "svelte";
 import { type AlertApi, type AlertProps, type AlertSlots } from './alert';
 declare const __propDef: {
     props: {
@@ -8,12 +8,14 @@ declare const __propDef: {
         [evt: string]: CustomEvent<any>;
     };
     slots: AlertSlots;
+    exports?: {} | undefined;
+    bindings?: string | undefined;
 };
 type AlertProps_ = typeof __propDef.props;
 export { AlertProps_ as AlertProps };
 export type AlertEvents = typeof __propDef.events;
 type AlertSlots_ = typeof __propDef.slots;
 export { AlertSlots_ as AlertSlots };
-export default class Alert extends SvelteComponentTyped<AlertProps_, AlertEvents, AlertSlots_> {
+export default class Alert extends SvelteComponent<AlertProps_, AlertEvents, AlertSlots_> {
     get api(): AlertApi;
 }