@agnos-ui/angular-bootstrap 0.4.0-next.1 → 0.4.1

package/esm2022/components/select/select.component.mjs

@@ -1,7 +1,7 @@
 import { BaseWidgetDirective, SlotDirective, UseDirective, UseMultiDirective, auBooleanAttribute, useDirectiveForHost, } from '@agnos-ui/angular-headless';
 import { ChangeDetectionStrategy, Component, ContentChild, Directive, EventEmitter, Input, Output, TemplateRef, inject } from '@angular/core';
 import { callWidgetFactory } from '../../config';
-import { createSelect } from './select';
+import { createSelect } from './select.gen';
 import * as i0 from "@angular/core";
 const _c0 = ["auSelect", ""];
 const _c1 = (a0, a1) => [a0, a1];
@@ -104,14 +104,31 @@ export class SelectComponent extends BaseWidgetDirective {
         super(...arguments);
         /**
          * Callback called when the text filter change
+         * @param text - Filtered text
+         *
+         * @defaultValue
+         * ```ts
+         * () => {}
+         * ```
          */
         this.filterTextChange = new EventEmitter();
         /**
          * Callback called when the selection change
+         *
+         * @defaultValue
+         * ```ts
+         * () => {}
+         * ```
          */
         this.selectedChange = new EventEmitter();
         /**
          * Callback called dropdown open state change
+         * @param isOpen - updated open state
+         *
+         * @defaultValue
+         * ```ts
+         * () => {}
+         * ```
          */
         this.openChange = new EventEmitter();
         this._widget = callWidgetFactory({
@@ -277,4 +294,4 @@ export class SelectComponent extends BaseWidgetDirective {
             args: ['auNavSelector']
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(SelectComponent, { className: "SelectComponent", filePath: "components/select/select.component.ts", lineNumber: 87 }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.component.js","sourceRoot":"","sources":["../../../../src/components/select/select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import type {SlotContent} from '@agnos-ui/angular-headless';\nimport {\n\tBaseWidgetDirective,\n\tSlotDirective,\n\tUseDirective,\n\tUseMultiDirective,\n\tauBooleanAttribute,\n\tuseDirectiveForHost,\n} from '@agnos-ui/angular-headless';\nimport type {AfterContentChecked} from '@angular/core';\nimport {ChangeDetectionStrategy, Component, ContentChild, Directive, EventEmitter, Input, Output, TemplateRef, inject} from '@angular/core';\nimport type {Placement} from '@floating-ui/dom';\nimport {callWidgetFactory} from '../../config';\nimport type {ItemContext, SelectItemContext, SelectWidget} from './select';\nimport {createSelect} from './select';\n\n@Directive({selector: 'ng-template[auSelectBadgeLabel]', standalone: true})\nexport class SelectBadgeLabelDirective<Item> {\n\tpublic templateRef = inject(TemplateRef<SelectItemContext<Item>>);\n\tstatic ngTemplateContextGuard<Item>(_dir: SelectBadgeLabelDirective<Item>, context: unknown): context is SelectItemContext<Item> {\n\t\treturn true;\n\t}\n}\n\n@Directive({selector: 'ng-template[auSelectItemLabel]', standalone: true})\nexport class SelectItemLabelDirective<Item> {\n\tpublic templateRef = inject(TemplateRef<SelectItemContext<Item>>);\n\tstatic ngTemplateContextGuard<Item>(_dir: SelectItemLabelDirective<Item>, context: unknown): context is SelectItemContext<Item> {\n\t\treturn true;\n\t}\n}\n\n@Component({\n\tstandalone: true,\n\timports: [UseMultiDirective, SlotDirective, UseDirective],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\tselector: '[auSelect]',\n\thost: {\n\t\t'[class]': '\"au-select dropdown border border-1 p-1 mb-3 d-block\" + state().className',\n\t},\n\ttemplate: `\n\t\t@if (state(); as state) {\n\t\t\t<div\n\t\t\t\t[auUseMulti]=\"[widget.directives.hasFocusDirective, widget.directives.inputContainerDirective]\"\n\t\t\t\tclass=\"d-flex align-items-center flex-wrap gap-1\"\n\t\t\t>\n\t\t\t\t@if (state.selectedContexts; as selectedContexts) {\n\t\t\t\t\t@for (itemContext of selectedContexts; track itemCtxTrackBy($index, itemContext)) {\n\t\t\t\t\t\t<div [auUse]=\"[_widget.directives.badgeAttributesDirective, itemContext]\">\n\t\t\t\t\t\t\t<ng-template [auSlot]=\"state.badgeLabel\" [auSlotProps]=\"{state, widget, itemContext}\"></ng-template>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t<input\n\t\t\t\t\tattr.id=\"{{ state.id }}\"\n\t\t\t\t\tattr.aria-label=\"{{ state.ariaLabel }}\"\n\t\t\t\t\ttype=\"text\"\n\t\t\t\t\tclass=\"au-select-input flex-grow-1 border-0\"\n\t\t\t\t\t[value]=\"state.filterText\"\n\t\t\t\t\taria-autocomplete=\"list\"\n\t\t\t\t\tautoCorrect=\"off\"\n\t\t\t\t\tautoCapitalize=\"none\"\n\t\t\t\t\tautoComplete=\"off\"\n\t\t\t\t\t(input)=\"_widget.actions.onInput($event)\"\n\t\t\t\t\t(keydown)=\"_widget.actions.onInputKeydown($event)\"\n\t\t\t\t/>\n\t\t\t</div>\n\t\t\t@if (state.open && state.visibleItems.length) {\n\t\t\t\t<ul\n\t\t\t\t\t[auUseMulti]=\"[widget.directives.hasFocusDirective, widget.directives.floatingDirective, widget.directives.menuAttributesDirective]\"\n\t\t\t\t\tclass=\"dropdown-menu show\"\n\t\t\t\t>\n\t\t\t\t\t@for (itemContext of state.visibleItems; track itemCtxTrackBy($index, itemContext)) {\n\t\t\t\t\t\t<li\n\t\t\t\t\t\t\tclass=\"dropdown-item position-relative\"\n\t\t\t\t\t\t\t[auUse]=\"[_widget.directives.itemAttributesDirective, itemContext]\"\n\t\t\t\t\t\t\t[class.text-bg-primary]=\"itemContext === state.highlighted\"\n\t\t\t\t\t\t>\n\t\t\t\t\t\t\t<ng-template [auSlot]=\"state.itemLabel\" [auSlotProps]=\"{state, widget, itemContext}\"></ng-template>\n\t\t\t\t\t\t</li>\n\t\t\t\t\t}\n\t\t\t\t</ul>\n\t\t\t}\n\t\t}\n\t`,\n})\nexport class SelectComponent<Item> extends BaseWidgetDirective<SelectWidget<Item>> implements AfterContentChecked {\n\t/**\n\t * aria-label used for the input inside the select\n\t */\n\t@Input('auAriaLabel') ariaLabel: string | undefined;\n\n\t/**\n\t * id used for the input inside the select\n\t */\n\t@Input('auId') id: string | undefined;\n\n\t/**\n\t * List of available items for the dropdown\n\t */\n\t@Input('auItems') items: Item[] | undefined;\n\n\t/**\n\t * List of allowed placements for the dropdown.\n\t * This refers to the [allowedPlacements from floating UI](https://floating-ui.com/docs/autoPlacement#allowedplacements), given the different [Placement possibilities](https://floating-ui.com/docs/computePosition#placement).\n\t */\n\t@Input('auAllowedPlacements') allowedPlacements: Placement[] | undefined;\n\n\t/**\n\t * true if the select is open\n\t */\n\t@Input({alias: 'auOpen', transform: auBooleanAttribute}) open: boolean | undefined;\n\n\t/**\n\t * Filtered text to be display in the filter input\n\t */\n\t@Input('auFilterText') filterText: string | undefined;\n\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t */\n\t@Input('auClassName') className: string | undefined;\n\n\t/**\n\t * true if the select is disabled\n\t */\n\t@Input({alias: 'auDisabled', transform: auBooleanAttribute}) disabled: boolean | undefined;\n\n\t/**\n\t * List of selected item ids\n\t */\n\t@Input('auSelected') selected: Item[] | undefined;\n\n\t/**\n\t * true if a loading process is being done\n\t */\n\t@Input({alias: 'auLoading', transform: auBooleanAttribute}) loading: boolean | undefined;\n\n\t/**\n\t * Custom function to get the id of an item\n\t * By default, the item is returned\n\t */\n\t@Input('auItemIdFn') itemIdFn: ((item: Item) => string) | undefined;\n\n\t/**\n\t * Class to be added on the dropdown menu container\n\t */\n\t@Input('auMenuClassName') menuClassName: string | undefined;\n\n\t/**\n\t * The template to override the way each badge on the left of the input is displayed.\n\t * This define the content of the badge inside the badge container.\n\t */\n\t@Input('auBadgeLabel') badgeLabel: SlotContent<SelectItemContext<Item>>;\n\t@ContentChild(SelectBadgeLabelDirective, {static: false}) slotSelectBadgeLabelFromContent: SelectBadgeLabelDirective<Item> | undefined;\n\n\t/**\n\t * The template to override the way each item is displayed in the list.\n\t * This define the content of the badge inside the badge container.\n\t */\n\t@Input('auItemLabel') itemLabel: SlotContent<SelectItemContext<Item>>;\n\t@ContentChild(SelectItemLabelDirective, {static: false}) slotSelectItemLabelFromContent: SelectItemLabelDirective<Item> | undefined;\n\n\t/**\n\t * Callback called when the text filter change\n\t */\n\t@Output('auFilterTextChange') filterTextChange = new EventEmitter<string>();\n\n\t/**\n\t * Callback called when the selection change\n\t */\n\t@Output('auSelectedChange') selectedChange = new EventEmitter<Item[]>();\n\n\t/**\n\t * Callback called dropdown open state change\n\t */\n\t@Output('auOpenChange') openChange = new EventEmitter<boolean>();\n\n\t/**\n\t * Class to be added on menu items\n\t */\n\t@Input('auMenuItemClassName') menuItemClassName: string | undefined;\n\n\t/**\n\t * Class to be added on selected items (displayed in the input zone)\n\t */\n\t@Input('auBadgeClassName') badgeClassName: string | undefined;\n\n\t/**\n\t * Retrieves navigable elements within an HTML element containing badges and the input.\n\t */\n\t@Input('auNavSelector') navSelector: ((node: HTMLElement) => NodeListOf<HTMLSpanElement | HTMLInputElement>) | undefined;\n\n\treadonly _widget = callWidgetFactory<SelectWidget<Item>>({\n\t\tfactory: createSelect,\n\t\twidgetName: 'select',\n\t\tevents: {\n\t\t\tonOpenChange: (event) => this.openChange.emit(event),\n\t\t\tonSelectedChange: (event) => this.selectedChange.emit(event),\n\t\t\tonFilterTextChange: (event) => this.filterTextChange.emit(event),\n\t\t},\n\t\tafterInit: () => {\n\t\t\tuseDirectiveForHost(this._widget.directives.referenceDirective);\n\t\t},\n\t});\n\n\titemCtxTrackBy(_: number, itemContext: ItemContext<Item>) {\n\t\treturn itemContext.id;\n\t}\n\n\tngAfterContentChecked(): void {\n\t\tthis._widget.patchSlots({\n\t\t\tbadgeLabel: this.slotSelectBadgeLabelFromContent?.templateRef,\n\t\t\titemLabel: this.slotSelectItemLabelFromContent?.templateRef,\n\t\t});\n\t}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.component.js","sourceRoot":"","sources":["../../../../src/components/select/select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import type {SlotContent} from '@agnos-ui/angular-headless';\nimport {\n\tBaseWidgetDirective,\n\tSlotDirective,\n\tUseDirective,\n\tUseMultiDirective,\n\tauBooleanAttribute,\n\tuseDirectiveForHost,\n} from '@agnos-ui/angular-headless';\nimport type {AfterContentChecked} from '@angular/core';\nimport {ChangeDetectionStrategy, Component, ContentChild, Directive, EventEmitter, Input, Output, TemplateRef, inject} from '@angular/core';\nimport type {Placement} from '@floating-ui/dom';\nimport {callWidgetFactory} from '../../config';\nimport type {ItemContext, SelectItemContext, SelectWidget} from './select.gen';\nimport {createSelect} from './select.gen';\n\n@Directive({selector: 'ng-template[auSelectBadgeLabel]', standalone: true})\nexport class SelectBadgeLabelDirective<Item> {\n\tpublic templateRef = inject(TemplateRef<SelectItemContext<Item>>);\n\tstatic ngTemplateContextGuard<Item>(_dir: SelectBadgeLabelDirective<Item>, context: unknown): context is SelectItemContext<Item> {\n\t\treturn true;\n\t}\n}\n\n@Directive({selector: 'ng-template[auSelectItemLabel]', standalone: true})\nexport class SelectItemLabelDirective<Item> {\n\tpublic templateRef = inject(TemplateRef<SelectItemContext<Item>>);\n\tstatic ngTemplateContextGuard<Item>(_dir: SelectItemLabelDirective<Item>, context: unknown): context is SelectItemContext<Item> {\n\t\treturn true;\n\t}\n}\n\n@Component({\n\tstandalone: true,\n\timports: [UseMultiDirective, SlotDirective, UseDirective],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\tselector: '[auSelect]',\n\thost: {\n\t\t'[class]': '\"au-select dropdown border border-1 p-1 mb-3 d-block\" + state().className',\n\t},\n\ttemplate: `\n\t\t@if (state(); as state) {\n\t\t\t<div\n\t\t\t\t[auUseMulti]=\"[widget.directives.hasFocusDirective, widget.directives.inputContainerDirective]\"\n\t\t\t\tclass=\"d-flex align-items-center flex-wrap gap-1\"\n\t\t\t>\n\t\t\t\t@if (state.selectedContexts; as selectedContexts) {\n\t\t\t\t\t@for (itemContext of selectedContexts; track itemCtxTrackBy($index, itemContext)) {\n\t\t\t\t\t\t<div [auUse]=\"[_widget.directives.badgeAttributesDirective, itemContext]\">\n\t\t\t\t\t\t\t<ng-template [auSlot]=\"state.badgeLabel\" [auSlotProps]=\"{state, widget, itemContext}\"></ng-template>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t<input\n\t\t\t\t\tattr.id=\"{{ state.id }}\"\n\t\t\t\t\tattr.aria-label=\"{{ state.ariaLabel }}\"\n\t\t\t\t\ttype=\"text\"\n\t\t\t\t\tclass=\"au-select-input flex-grow-1 border-0\"\n\t\t\t\t\t[value]=\"state.filterText\"\n\t\t\t\t\taria-autocomplete=\"list\"\n\t\t\t\t\tautoCorrect=\"off\"\n\t\t\t\t\tautoCapitalize=\"none\"\n\t\t\t\t\tautoComplete=\"off\"\n\t\t\t\t\t(input)=\"_widget.actions.onInput($event)\"\n\t\t\t\t\t(keydown)=\"_widget.actions.onInputKeydown($event)\"\n\t\t\t\t/>\n\t\t\t</div>\n\t\t\t@if (state.open && state.visibleItems.length) {\n\t\t\t\t<ul\n\t\t\t\t\t[auUseMulti]=\"[widget.directives.hasFocusDirective, widget.directives.floatingDirective, widget.directives.menuAttributesDirective]\"\n\t\t\t\t\tclass=\"dropdown-menu show\"\n\t\t\t\t>\n\t\t\t\t\t@for (itemContext of state.visibleItems; track itemCtxTrackBy($index, itemContext)) {\n\t\t\t\t\t\t<li\n\t\t\t\t\t\t\tclass=\"dropdown-item position-relative\"\n\t\t\t\t\t\t\t[auUse]=\"[_widget.directives.itemAttributesDirective, itemContext]\"\n\t\t\t\t\t\t\t[class.text-bg-primary]=\"itemContext === state.highlighted\"\n\t\t\t\t\t\t>\n\t\t\t\t\t\t\t<ng-template [auSlot]=\"state.itemLabel\" [auSlotProps]=\"{state, widget, itemContext}\"></ng-template>\n\t\t\t\t\t\t</li>\n\t\t\t\t\t}\n\t\t\t\t</ul>\n\t\t\t}\n\t\t}\n\t`,\n})\nexport class SelectComponent<Item> extends BaseWidgetDirective<SelectWidget<Item>> implements AfterContentChecked {\n\t/**\n\t * aria-label used for the input inside the select\n\t *\n\t * @defaultValue `'Select'`\n\t */\n\t@Input('auAriaLabel') ariaLabel: string | undefined;\n\n\t/**\n\t * id used for the input inside the select\n\t */\n\t@Input('auId') id: string | undefined;\n\n\t/**\n\t * List of available items for the dropdown\n\t *\n\t * @defaultValue `[]`\n\t */\n\t@Input('auItems') items: Item[] | undefined;\n\n\t/**\n\t * List of allowed placements for the dropdown.\n\t * This refers to the [allowedPlacements from floating UI](https://floating-ui.com/docs/autoPlacement#allowedplacements), given the different [Placement possibilities](https://floating-ui.com/docs/computePosition#placement).\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ['bottom-start', 'top-start', 'bottom-end', 'top-end']\n\t * ```\n\t */\n\t@Input('auAllowedPlacements') allowedPlacements: Placement[] | undefined;\n\n\t/**\n\t * true if the select is open\n\t *\n\t * @defaultValue `false`\n\t */\n\t@Input({alias: 'auOpen', transform: auBooleanAttribute}) open: boolean | undefined;\n\n\t/**\n\t * Filtered text to be display in the filter input\n\t *\n\t * @defaultValue `''`\n\t */\n\t@Input('auFilterText') filterText: string | undefined;\n\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t *\n\t * @defaultValue `''`\n\t */\n\t@Input('auClassName') className: string | undefined;\n\n\t/**\n\t * true if the select is disabled\n\t *\n\t * @defaultValue `false`\n\t */\n\t@Input({alias: 'auDisabled', transform: auBooleanAttribute}) disabled: boolean | undefined;\n\n\t/**\n\t * List of selected item ids\n\t *\n\t * @defaultValue `[]`\n\t */\n\t@Input('auSelected') selected: Item[] | undefined;\n\n\t/**\n\t * true if a loading process is being done\n\t *\n\t * @defaultValue `false`\n\t */\n\t@Input({alias: 'auLoading', transform: auBooleanAttribute}) loading: boolean | undefined;\n\n\t/**\n\t * Custom function to get the id of an item\n\t * By default, the item is returned\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * (item: any) => '' + item\n\t * ```\n\t */\n\t@Input('auItemIdFn') itemIdFn: ((item: Item) => string) | undefined;\n\n\t/**\n\t * Class to be added on the dropdown menu container\n\t *\n\t * @defaultValue `''`\n\t */\n\t@Input('auMenuClassName') menuClassName: string | undefined;\n\n\t/**\n\t * The template to override the way each badge on the left of the input is displayed.\n\t * This define the content of the badge inside the badge container.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ({itemContext}: SelectItemContext<any>) => itemContext.item\n\t * ```\n\t */\n\t@Input('auBadgeLabel') badgeLabel: SlotContent<SelectItemContext<Item>>;\n\t@ContentChild(SelectBadgeLabelDirective, {static: false}) slotSelectBadgeLabelFromContent: SelectBadgeLabelDirective<Item> | undefined;\n\n\t/**\n\t * The template to override the way each item is displayed in the list.\n\t * This define the content of the badge inside the badge container.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ({itemContext}: SelectItemContext<any>) => itemContext.item\n\t * ```\n\t */\n\t@Input('auItemLabel') itemLabel: SlotContent<SelectItemContext<Item>>;\n\t@ContentChild(SelectItemLabelDirective, {static: false}) slotSelectItemLabelFromContent: SelectItemLabelDirective<Item> | undefined;\n\n\t/**\n\t * Callback called when the text filter change\n\t * @param text - Filtered text\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\t@Output('auFilterTextChange') filterTextChange = new EventEmitter<string>();\n\n\t/**\n\t * Callback called when the selection change\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\t@Output('auSelectedChange') selectedChange = new EventEmitter<Item[]>();\n\n\t/**\n\t * Callback called dropdown open state change\n\t * @param isOpen - updated open state\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\t@Output('auOpenChange') openChange = new EventEmitter<boolean>();\n\n\t/**\n\t * Class to be added on menu items\n\t *\n\t * @defaultValue `''`\n\t */\n\t@Input('auMenuItemClassName') menuItemClassName: string | undefined;\n\n\t/**\n\t * Class to be added on selected items (displayed in the input zone)\n\t *\n\t * @defaultValue `''`\n\t */\n\t@Input('auBadgeClassName') badgeClassName: string | undefined;\n\n\t/**\n\t * Retrieves navigable elements within an HTML element containing badges and the input.\n\t *\n\t * @param node - HTMLElement that contains the badges and the input\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * (node: HTMLElement) => node.querySelectorAll('.au-select-badge,input')\n\t * ```\n\t */\n\t@Input('auNavSelector') navSelector: ((node: HTMLElement) => NodeListOf<HTMLSpanElement | HTMLInputElement>) | undefined;\n\n\treadonly _widget = callWidgetFactory<SelectWidget<Item>>({\n\t\tfactory: createSelect,\n\t\twidgetName: 'select',\n\t\tevents: {\n\t\t\tonOpenChange: (event) => this.openChange.emit(event),\n\t\t\tonSelectedChange: (event) => this.selectedChange.emit(event),\n\t\t\tonFilterTextChange: (event) => this.filterTextChange.emit(event),\n\t\t},\n\t\tafterInit: () => {\n\t\t\tuseDirectiveForHost(this._widget.directives.referenceDirective);\n\t\t},\n\t});\n\n\titemCtxTrackBy(_: number, itemContext: ItemContext<Item>) {\n\t\treturn itemContext.id;\n\t}\n\n\tngAfterContentChecked(): void {\n\t\tthis._widget.patchSlots({\n\t\t\tbadgeLabel: this.slotSelectBadgeLabelFromContent?.templateRef,\n\t\t\titemLabel: this.slotSelectItemLabelFromContent?.templateRef,\n\t\t});\n\t}\n}\n"]}

package/esm2022/components/select/select.gen.mjs

@@ -1,2 +1,15 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.gen.js","sourceRoot":"","sources":["../../../../src/components/select/select.gen.ts"],"names":[],"mappings":"","sourcesContent":["import type {WidgetSlotContext, SlotContent, Widget, HasFocus, FloatingUI, Directive} from '@agnos-ui/angular-headless';\nimport type {Placement} from '@floating-ui/dom';\n\nexport type SelectContext<Item> = WidgetSlotContext<SelectWidget<Item>>;\n\nexport type SelectItemContext<Item> = SelectContext<Item> & {\n\t/**\n\t * Contextual data related to an item\n\t */\n\titemContext: ItemContext<Item>;\n};\n\nexport interface SelectState<Item> {\n\t/**\n\t * List of item contexts, to be displayed in the menu\n\t */\n\tvisibleItems: ItemContext<Item>[];\n\t/**\n\t * List of selected items to be display\n\t */\n\tselectedContexts: ItemContext<Item>[];\n\t/**\n\t * Highlighted item context.\n\t * It is designed to define the highlighted item in the dropdown menu\n\t */\n\thighlighted: ItemContext<Item> | undefined;\n\t/**\n\t * Current placement of the dropdown\n\t */\n\tplacement: Placement | undefined;\n\t/**\n\t * id used for the input inside the select\n\t */\n\tid: string | undefined;\n\t/**\n\t * aria-label used for the input inside the select\n\t */\n\tariaLabel: string | undefined;\n\t/**\n\t * List of selected item ids\n\t */\n\tselected: Item[];\n\t/**\n\t * Filtered text to be display in the filter input\n\t */\n\tfilterText: string;\n\t/**\n\t * true if the select is disabled\n\t */\n\tdisabled: boolean;\n\t/**\n\t * true if the select is open\n\t */\n\topen: boolean;\n\t/**\n\t * Class to be added on the dropdown menu container\n\t */\n\tmenuClassName: string;\n\t/**\n\t * Class to be added on menu items\n\t */\n\tmenuItemClassName: string;\n\t/**\n\t * Class to be added on selected items (displayed in the input zone)\n\t */\n\tbadgeClassName: string;\n\t/**\n\t * true if a loading process is being done\n\t */\n\tloading: boolean;\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t */\n\tclassName: string;\n\t/**\n\t * The template to override the way each badge on the left of the input is displayed.\n\t * This define the content of the badge inside the badge container.\n\t */\n\tbadgeLabel: SlotContent<SelectItemContext<Item>>;\n\t/**\n\t * The template to override the way each item is displayed in the list.\n\t * This define the content of the badge inside the badge container.\n\t */\n\titemLabel: SlotContent<SelectItemContext<Item>>;\n}\n\nexport interface SelectProps<Item> {\n\t/**\n\t * List of available items for the dropdown\n\t */\n\titems: Item[];\n\t/**\n\t * List of allowed placements for the dropdown.\n\t * This refers to the [allowedPlacements from floating UI](https://floating-ui.com/docs/autoPlacement#allowedplacements), given the different [Placement possibilities](https://floating-ui.com/docs/computePosition#placement).\n\t */\n\tallowedPlacements: Placement[];\n\t/**\n\t * Custom function to get the id of an item\n\t * By default, the item is returned\n\t */\n\titemIdFn(item: Item): string;\n\t/**\n\t * Retrieves navigable elements within an HTML element containing badges and the input.\n\t */\n\tnavSelector(node: HTMLElement): NodeListOf<HTMLSpanElement | HTMLInputElement>;\n\t/**\n\t * Callback called dropdown open state change\n\t */\n\tonOpenChange(isOpen: boolean): void;\n\t/**\n\t * Callback called when the text filter change\n\t */\n\tonFilterTextChange(text: string): void;\n\t/**\n\t * Callback called when the selection change\n\t */\n\tonSelectedChange(selected: Item[]): void;\n\t/**\n\t * id used for the input inside the select\n\t */\n\tid: string | undefined;\n\t/**\n\t * aria-label used for the input inside the select\n\t */\n\tariaLabel: string | undefined;\n\t/**\n\t * List of selected item ids\n\t */\n\tselected: Item[];\n\t/**\n\t * Filtered text to be display in the filter input\n\t */\n\tfilterText: string;\n\t/**\n\t * true if the select is disabled\n\t */\n\tdisabled: boolean;\n\t/**\n\t * true if the select is open\n\t */\n\topen: boolean;\n\t/**\n\t * Class to be added on the dropdown menu container\n\t */\n\tmenuClassName: string;\n\t/**\n\t * Class to be added on menu items\n\t */\n\tmenuItemClassName: string;\n\t/**\n\t * Class to be added on selected items (displayed in the input zone)\n\t */\n\tbadgeClassName: string;\n\t/**\n\t * true if a loading process is being done\n\t */\n\tloading: boolean;\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t */\n\tclassName: string;\n\t/**\n\t * The template to override the way each badge on the left of the input is displayed.\n\t * This define the content of the badge inside the badge container.\n\t */\n\tbadgeLabel: SlotContent<SelectItemContext<Item>>;\n\t/**\n\t * The template to override the way each item is displayed in the list.\n\t * This define the content of the badge inside the badge container.\n\t */\n\titemLabel: SlotContent<SelectItemContext<Item>>;\n}\n\nexport type SelectWidget<Item> = Widget<SelectProps<Item>, SelectState<Item>, SelectApi<Item>, SelectActions<Item>, SelectDirectives<Item>>;\n\nexport interface ItemContext<T> {\n\t/**\n\t * Original item given in the parameters\n\t */\n\titem: T;\n\t/**\n\t * Unique id to identify the item\n\t */\n\tid: string;\n\t/**\n\t * Specify if the item is checked\n\t */\n\tselected: boolean;\n}\n\nexport interface SelectApi<Item> {\n\t/**\n\t * Clear all the selected items\n\t */\n\tclear(): void;\n\t/**\n\t * Clear the filter text\n\t */\n\tclearText(): void;\n\t/**\n\t * Highlight the given item, if there is a corresponding match among the visible list\n\t */\n\thighlight(item: Item): void;\n\t/**\n\t * Highlight the first item among the visible list\n\t */\n\thighlightFirst(): void;\n\t/**\n\t * Highlight the previous item among the visible list\n\t * Loop to the last item if needed\n\t */\n\thighlightPrevious(): void;\n\t/**\n\t * Highlight the next item among the visible list.\n\t * Loop to the first item if needed\n\t */\n\thighlightNext(): void;\n\t/**\n\t * Highlight the last item among the visible list\n\t */\n\thighlightLast(): void;\n\t/**\n\t * Select the provided item.\n\t * The selected list is used to\n\t */\n\tselect(item: Item): void;\n\t/**\n\t * Unselect the provided item.\n\t */\n\tunselect(item: Item): void;\n\t/**\n\t * Toggle the selection of an item\n\t */\n\ttoggleItem(item: Item, selected?: boolean): void;\n\t/**\n\t * open the select\n\t */\n\topen(): void;\n\t/**\n\t * close the select\n\t */\n\tclose(): void;\n\t/**\n\t * Toggle the dropdown menu\n\t */\n\ttoggle(isOpen?: boolean): void;\n}\n\nexport interface SelectDirectives<Item> {\n\t/**\n\t * Directive to be used in the input group and the menu containers\n\t */\n\thasFocusDirective: HasFocus['directive'];\n\t/**\n\t * Directive that enables dynamic positioning of menu element\n\t */\n\tfloatingDirective: FloatingUI['directives']['floatingDirective'];\n\t/**\n\t * A directive to be applied to the input group element serves as the base for menu positioning\n\t */\n\treferenceDirective: FloatingUI['directives']['referenceDirective'];\n\t/**\n\t * A directive to be applied to the element that contains the badges and the input\n\t */\n\tinputContainerDirective: Directive;\n\t/**\n\t * A directive that applies all the necessary attributes to the container badges\n\t */\n\tbadgeAttributesDirective: Directive<ItemContext<Item>>;\n\t/**\n\t * A directive that applies all the necessary attributes to the dropdown menu\n\t */\n\tmenuAttributesDirective: Directive;\n\t/**\n\t * A directive that applies all the necessary attributes to the dropdown item\n\t */\n\titemAttributesDirective: Directive<ItemContext<Item>>;\n}\n\nexport interface SelectActions<Item> {\n\t/**\n\t * Method to be plugged to on the 'input' event. The input text will be used as the filter text.\n\t */\n\tonInput: (e: {target: any}) => void;\n\t/**\n\t * Method to be attached to the node element to close a badge on click.\n\t */\n\tonRemoveBadgeClick: (event: MouseEvent, item: Item) => void;\n\t/**\n\t * Method to be plugged to on an keydown event of the main input, in order to control the keyboard interactions with the highlighted item.\n\t * It manages arrow keys to move the highlighted item, or enter to toggle the item.\n\t */\n\tonInputKeydown: (event: KeyboardEvent) => void;\n\t/**\n\t * Method to be plugged to on an keydown event of a badge container, in order to manage main actions on badges.\n\t */\n\tonBadgeKeydown: (event: KeyboardEvent, item: Item) => void;\n}\n\n"]}
+import { getSelectDefaultConfig, createSelect } from '@agnos-ui/core-bootstrap/components/select';
+/**
+ * Retrieve a shallow copy of the default Select config
+ * @returns the default Select config
+ */
+const export_getSelectDefaultConfig = getSelectDefaultConfig;
+export { export_getSelectDefaultConfig as getSelectDefaultConfig };
+/**
+ * Creates a new select widget instance.
+ * @param config - config of the modal, either as a store or as an object containing values or stores.
+ * @returns a new select widget instance
+ */
+const export_createSelect = createSelect;
+export { export_createSelect as createSelect };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.gen.js","sourceRoot":"","sources":["../../../../src/components/select/select.gen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,sBAAsB,EAAE,YAAY,EAAC,MAAM,4CAA4C,CAAC;AAMhG;;;GAGG;AACH,MAAM,6BAA6B,GAA2B,sBAA6B,CAAC;AAC5F,OAAO,EAAC,6BAA6B,IAAI,sBAAsB,EAAC,CAAC;AA6VjE;;;;GAIG;AACH,MAAM,mBAAmB,GAA0E,YAAmB,CAAC;AACvH,OAAO,EAAC,mBAAmB,IAAI,YAAY,EAAC,CAAC","sourcesContent":["import {getSelectDefaultConfig, createSelect} from '@agnos-ui/core-bootstrap/components/select';\nimport type {WidgetSlotContext, SlotContent, Widget, PropsConfig, HasFocus, FloatingUI, Directive} from '@agnos-ui/angular-headless';\nimport type {Placement} from '@floating-ui/dom';\n\n\n\n/**\n * Retrieve a shallow copy of the default Select config\n * @returns the default Select config\n */\nconst export_getSelectDefaultConfig: () => SelectProps<any> = getSelectDefaultConfig as any;\nexport {export_getSelectDefaultConfig as getSelectDefaultConfig};\n\n\n\n/**\n * A type for the slot context of the pagination widget\n */\nexport type SelectContext<Item> = WidgetSlotContext<SelectWidget<Item>>;\n\n\n\nexport type SelectItemContext<Item> = SelectContext<Item> & {\n\t/**\n\t * Contextual data related to an item\n\t */\n\titemContext: ItemContext<Item>;\n};\n\nexport interface SelectState<Item> {\n\t\n\t/**\n\t * List of item contexts, to be displayed in the menu\n\t */\n\tvisibleItems: ItemContext<Item>[];\n\t\n\n\t/**\n\t * List of selected items to be display\n\t */\n\tselectedContexts: ItemContext<Item>[];\n\t\n\n\t/**\n\t * Highlighted item context.\n\t * It is designed to define the highlighted item in the dropdown menu\n\t */\n\thighlighted: ItemContext<Item> | undefined;\n\t\n\n\t/**\n\t * Current placement of the dropdown\n\t */\n\tplacement: Placement | undefined;\n\t\n\t/**\n\t * id used for the input inside the select\n\t */\n\tid: string | undefined;\n\t\n\n\t/**\n\t * aria-label used for the input inside the select\n\t *\n\t * @defaultValue `'Select'`\n\t */\n\tariaLabel: string | undefined;\n\t\n\n\t/**\n\t * List of selected item ids\n\t *\n\t * @defaultValue `[]`\n\t */\n\tselected: Item[];\n\t\n\n\t/**\n\t * Filtered text to be display in the filter input\n\t *\n\t * @defaultValue `''`\n\t */\n\tfilterText: string;\n\t\n\n\t/**\n\t * true if the select is disabled\n\t *\n\t * @defaultValue `false`\n\t */\n\tdisabled: boolean;\n\t\n\n\t/**\n\t * true if the select is open\n\t *\n\t * @defaultValue `false`\n\t */\n\topen: boolean;\n\t\n\n\t/**\n\t * Class to be added on the dropdown menu container\n\t *\n\t * @defaultValue `''`\n\t */\n\tmenuClassName: string;\n\t\n\n\t/**\n\t * Class to be added on menu items\n\t *\n\t * @defaultValue `''`\n\t */\n\tmenuItemClassName: string;\n\t\n\n\t/**\n\t * Class to be added on selected items (displayed in the input zone)\n\t *\n\t * @defaultValue `''`\n\t */\n\tbadgeClassName: string;\n\t\n\n\t/**\n\t * true if a loading process is being done\n\t *\n\t * @defaultValue `false`\n\t */\n\tloading: boolean;\n\t\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t *\n\t * @defaultValue `''`\n\t */\n\tclassName: string;\n\t\n\t/**\n\t * The template to override the way each badge on the left of the input is displayed.\n\t * This define the content of the badge inside the badge container.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ({itemContext}: SelectItemContext<any>) => itemContext.item\n\t * ```\n\t */\n\tbadgeLabel: SlotContent<SelectItemContext<Item>>;\n\t\n\n\t/**\n\t * The template to override the way each item is displayed in the list.\n\t * This define the content of the badge inside the badge container.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ({itemContext}: SelectItemContext<any>) => itemContext.item\n\t * ```\n\t */\n\titemLabel: SlotContent<SelectItemContext<Item>>;\n}\n\nexport interface SelectProps<Item> {\n\t\n\t/**\n\t * List of available items for the dropdown\n\t *\n\t * @defaultValue `[]`\n\t */\n\titems: Item[];\n\t\n\n\t/**\n\t * List of allowed placements for the dropdown.\n\t * This refers to the [allowedPlacements from floating UI](https://floating-ui.com/docs/autoPlacement#allowedplacements), given the different [Placement possibilities](https://floating-ui.com/docs/computePosition#placement).\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ['bottom-start', 'top-start', 'bottom-end', 'top-end']\n\t * ```\n\t */\n\tallowedPlacements: Placement[];\n\t\n\n\t/**\n\t * Custom function to get the id of an item\n\t * By default, the item is returned\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * (item: any) => '' + item\n\t * ```\n\t */\n\titemIdFn(item: Item): string;\n\t\n\n\t/**\n\t * Retrieves navigable elements within an HTML element containing badges and the input.\n\t *\n\t * @param node - HTMLElement that contains the badges and the input\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * (node: HTMLElement) => node.querySelectorAll('.au-select-badge,input')\n\t * ```\n\t */\n\tnavSelector(node: HTMLElement): NodeListOf<HTMLSpanElement | HTMLInputElement>;\n\t\n\n\t// Event callbacks\n\n\t/**\n\t * Callback called dropdown open state change\n\t * @param isOpen - updated open state\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\tonOpenChange(isOpen: boolean): void;\n\t\n\n\t/**\n\t * Callback called when the text filter change\n\t * @param text - Filtered text\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\tonFilterTextChange(text: string): void;\n\t\n\n\t/**\n\t * Callback called when the selection change\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\tonSelectedChange(selected: Item[]): void;\n\t\n\t/**\n\t * id used for the input inside the select\n\t */\n\tid: string | undefined;\n\t\n\n\t/**\n\t * aria-label used for the input inside the select\n\t *\n\t * @defaultValue `'Select'`\n\t */\n\tariaLabel: string | undefined;\n\t\n\n\t/**\n\t * List of selected item ids\n\t *\n\t * @defaultValue `[]`\n\t */\n\tselected: Item[];\n\t\n\n\t/**\n\t * Filtered text to be display in the filter input\n\t *\n\t * @defaultValue `''`\n\t */\n\tfilterText: string;\n\t\n\n\t/**\n\t * true if the select is disabled\n\t *\n\t * @defaultValue `false`\n\t */\n\tdisabled: boolean;\n\t\n\n\t/**\n\t * true if the select is open\n\t *\n\t * @defaultValue `false`\n\t */\n\topen: boolean;\n\t\n\n\t/**\n\t * Class to be added on the dropdown menu container\n\t *\n\t * @defaultValue `''`\n\t */\n\tmenuClassName: string;\n\t\n\n\t/**\n\t * Class to be added on menu items\n\t *\n\t * @defaultValue `''`\n\t */\n\tmenuItemClassName: string;\n\t\n\n\t/**\n\t * Class to be added on selected items (displayed in the input zone)\n\t *\n\t * @defaultValue `''`\n\t */\n\tbadgeClassName: string;\n\t\n\n\t/**\n\t * true if a loading process is being done\n\t *\n\t * @defaultValue `false`\n\t */\n\tloading: boolean;\n\t\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t *\n\t * @defaultValue `''`\n\t */\n\tclassName: string;\n\t\n\t/**\n\t * The template to override the way each badge on the left of the input is displayed.\n\t * This define the content of the badge inside the badge container.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ({itemContext}: SelectItemContext<any>) => itemContext.item\n\t * ```\n\t */\n\tbadgeLabel: SlotContent<SelectItemContext<Item>>;\n\t\n\n\t/**\n\t * The template to override the way each item is displayed in the list.\n\t * This define the content of the badge inside the badge container.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ({itemContext}: SelectItemContext<any>) => itemContext.item\n\t * ```\n\t */\n\titemLabel: SlotContent<SelectItemContext<Item>>;\n}\n\n\n\nexport type SelectWidget<Item> = Widget<SelectProps<Item>, SelectState<Item>, SelectApi<Item>, SelectActions<Item>, SelectDirectives<Item>>;\n\n\n\n/**\n * Creates a new select widget instance.\n * @param config - config of the modal, either as a store or as an object containing values or stores.\n * @returns a new select widget instance\n */\nconst export_createSelect: <Item>(config?: PropsConfig<SelectProps<Item>>) => SelectWidget<Item> = createSelect as any;\nexport {export_createSelect as createSelect};\n\nexport interface ItemContext<T> {\n\t\n\t/**\n\t * Original item given in the parameters\n\t */\n\titem: T;\n\t\n\n\t/**\n\t * Unique id to identify the item\n\t */\n\tid: string;\n\t\n\n\t/**\n\t * Specify if the item is checked\n\t */\n\tselected: boolean;\n}\n\nexport interface SelectApi<Item> {\n\t\n\t/**\n\t * Clear all the selected items\n\t */\n\tclear(): void;\n\t\n\n\t/**\n\t * Clear the filter text\n\t */\n\tclearText(): void;\n\t\n\n\t/**\n\t * Highlight the given item, if there is a corresponding match among the visible list\n\t */\n\thighlight(item: Item): void;\n\t\n\n\t/**\n\t * Highlight the first item among the visible list\n\t */\n\thighlightFirst(): void;\n\t\n\n\t/**\n\t * Highlight the previous item among the visible list\n\t * Loop to the last item if needed\n\t */\n\thighlightPrevious(): void;\n\t\n\n\t/**\n\t * Highlight the next item among the visible list.\n\t * Loop to the first item if needed\n\t */\n\thighlightNext(): void;\n\t\n\n\t/**\n\t * Highlight the last item among the visible list\n\t */\n\thighlightLast(): void;\n\t\n\n\t/**\n\t * Select the provided item.\n\t * The selected list is used to\n\t * @param item - the item to select\n\t */\n\tselect(item: Item): void;\n\t\n\t/**\n\t * Unselect the provided item.\n\t * @param item - the item to unselect\n\t */\n\tunselect(item: Item): void;\n\t\n\t/**\n\t * Toggle the selection of an item\n\t * @param item - the item to toggle\n\t * @param selected - an optional boolean to enforce the selected/unselected state instead of toggling\n\t */\n\ttoggleItem(item: Item, selected?: boolean): void;\n\t\n\n\t/**\n\t * open the select\n\t */\n\topen(): void;\n\t\n\t/**\n\t * close the select\n\t */\n\tclose(): void;\n\t\n\t/**\n\t * Toggle the dropdown menu\n\t * @param isOpen - If specified, set the menu in the defined state.\n\t */\n\ttoggle(isOpen?: boolean): void;\n}\n\nexport interface SelectDirectives<Item> {\n\t\n\t/**\n\t * Directive to be used in the input group and the menu containers\n\t */\n\thasFocusDirective: HasFocus['directive'];\n\t\n\n\t/**\n\t * Directive that enables dynamic positioning of menu element\n\t */\n\tfloatingDirective: FloatingUI['directives']['floatingDirective'];\n\t\n\n\t/**\n\t * A directive to be applied to the input group element serves as the base for menu positioning\n\t */\n\treferenceDirective: FloatingUI['directives']['referenceDirective'];\n\t\n\n\t/**\n\t * A directive to be applied to the element that contains the badges and the input\n\t */\n\tinputContainerDirective: Directive;\n\t\n\n\t/**\n\t * A directive that applies all the necessary attributes to the container badges\n\t */\n\tbadgeAttributesDirective: Directive<ItemContext<Item>>;\n\t\n\n\t/**\n\t * A directive that applies all the necessary attributes to the dropdown menu\n\t */\n\tmenuAttributesDirective: Directive;\n\t\n\n\t/**\n\t * A directive that applies all the necessary attributes to the dropdown item\n\t */\n\titemAttributesDirective: Directive<ItemContext<Item>>;\n}\n\nexport interface SelectActions<Item> {\n\t\n\t// Dom methods\n\n\t/**\n\t * Method to be plugged to on the 'input' event. The input text will be used as the filter text.\n\t */\n\tonInput: (e: {target: any}) => void;\n\t\n\n\t/**\n\t * Method to be attached to the node element to close a badge on click.\n\t */\n\tonRemoveBadgeClick: (event: MouseEvent, item: Item) => void;\n\t\n\n\t/**\n\t * Method to be plugged to on an keydown event of the main input, in order to control the keyboard interactions with the highlighted item.\n\t * It manages arrow keys to move the highlighted item, or enter to toggle the item.\n\t */\n\tonInputKeydown: (event: KeyboardEvent) => void;\n\t\n\n\t/**\n\t * Method to be plugged to on an keydown event of a badge container, in order to manage main actions on badges.\n\t *\n\t * @param event - keyboard event\n\t * @param item - corresponding item\n\t */\n\tonBadgeKeydown: (event: KeyboardEvent, item: Item) => void;\n}\n\n"]}

package/esm2022/components/slider/index.mjs

@@ -1,3 +1,3 @@
 export * from './slider.component';
-export * from './slider';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9zbGlkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2xpZGVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3NsaWRlcic7XG4iXX0=
+export * from './slider.gen';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9zbGlkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2xpZGVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3NsaWRlci5nZW4nO1xuIl19

package/esm2022/components/slider/slider.component.mjs

@@ -4,7 +4,7 @@ import { ChangeDetectionStrategy, Component, ContentChild, Directive, EventEmitt
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
 import { take } from 'rxjs';
 import { callWidgetFactory } from '../../config';
-import { createSlider } from './slider';
+import { createSlider } from './slider.gen';
 import * as i0 from "@angular/core";
 const _c0 = ["handle"];
 const _c1 = a0 => ({ item: a0 });
@@ -305,6 +305,11 @@ export class SliderComponent extends BaseWidgetDirective {
          * An event emitted when slider values are changed
          *
          * Event payload equals to the updated slider values
+         *
+         * @defaultValue
+         * ```ts
+         * () => {}
+         * ```
          */
         this.valuesChange = new EventEmitter();
         /**
@@ -440,4 +445,4 @@ export class SliderComponent extends BaseWidgetDirective {
             args: [SliderHandleDirective, { static: false }]
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(SliderComponent, { className: "SliderComponent", filePath: "components/slider/slider.component.ts", lineNumber: 147 }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider.component.js","sourceRoot":"","sources":["../../../../src/components/slider/slider.component.ts"],"names":[],"mappings":"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","sourcesContent":["import type {SlotContent} from '@agnos-ui/angular-headless';\nimport {\n\tBaseWidgetDirective,\n\tComponentTemplate,\n\tSlotDirective,\n\tUseDirective,\n\tauBooleanAttribute,\n\tauNumberAttribute,\n\tuseDirectiveForHost,\n} from '@agnos-ui/angular-headless';\nimport {type WritableSignal, writable} from '@amadeus-it-group/tansu';\nimport type {AfterContentChecked} from '@angular/core';\nimport {\n\tChangeDetectionStrategy,\n\tComponent,\n\tContentChild,\n\tDirective,\n\tEventEmitter,\n\tInput,\n\tNgZone,\n\tOutput,\n\tTemplateRef,\n\tViewChild,\n\tViewEncapsulation,\n\tforwardRef,\n\tinject,\n} from '@angular/core';\nimport {NG_VALUE_ACCESSOR} from '@angular/forms';\nimport {take} from 'rxjs';\nimport {callWidgetFactory} from '../../config';\nimport type {SliderContext, SliderProps, SliderSlotHandleContext, SliderSlotLabelContext, SliderWidget} from './slider';\nimport {createSlider} from './slider';\n\n@Directive({selector: 'ng-template[auSliderLabel]', standalone: true})\nexport class SliderLabelDirective {\n\tpublic templateRef = inject(TemplateRef<SliderSlotLabelContext>);\n\tstatic ngTemplateContextGuard(_dir: SliderLabelDirective, context: unknown): context is SliderSlotLabelContext {\n\t\treturn true;\n\t}\n}\n\n@Directive({selector: 'ng-template[auSliderHandle]', standalone: true})\nexport class SliderHandleDirective {\n\tpublic templateRef = inject(TemplateRef<SliderSlotLabelContext>);\n\tstatic ngTemplateContextGuard(_dir: SliderHandleDirective, context: unknown): context is SliderSlotHandleContext {\n\t\treturn true;\n\t}\n}\n\n@Component({\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [UseDirective, SliderHandleDirective],\n\ttemplate: `\n\t\t<ng-template auSliderHandle #handle let-state=\"state\" let-widget=\"widget\" let-item=\"item\">\n\t\t\t<button [auUse]=\"[widget.directives.handleDirective, {item}]\">&nbsp;</button>\n\t\t</ng-template>\n\t`,\n})\nexport class SliderDefaultHandleSlotComponent {\n\tprivate readonly _zone = inject(NgZone);\n\n\t@ViewChild('handle', {static: true}) readonly handle!: TemplateRef<SliderSlotHandleContext>;\n\n\tonKeyDown(event: KeyboardEvent, handleId: number, widgetOnKeyDownFn: (event: KeyboardEvent, handleId: number) => void) {\n\t\twidgetOnKeyDownFn(event, handleId);\n\t\tthis._zone.onStable.pipe(take(1)).subscribe(() => {\n\t\t\t(event.target as HTMLElement).focus();\n\t\t});\n\t}\n}\n\nexport const sliderDefaultSlotHandle = new ComponentTemplate(SliderDefaultHandleSlotComponent, 'handle');\n\n@Directive({selector: 'ng-template[auSliderStructure]', standalone: true})\nexport class SliderStructureDirective {\n\tpublic templateRef = inject(TemplateRef<SliderSlotHandleContext>);\n\tstatic ngTemplateContextGuard(_dir: SliderStructureDirective, context: unknown): context is SliderSlotHandleContext {\n\t\treturn true;\n\t}\n}\n\n@Component({\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [SlotDirective, SliderStructureDirective, UseDirective],\n\ttemplate: `\n\t\t<ng-template auSliderStructure #structure let-state=\"state\" let-widget=\"widget\">\n\t\t\t@for (option of state.progressDisplayOptions; track option) {\n\t\t\t\t<div [auUse]=\"[widget.directives.progressDisplayDirective, {option}]\"></div>\n\t\t\t}\n\t\t\t<div [auUse]=\"widget.directives.clickableAreaDirective\"></div>\n\t\t\t@if (state.showMinMaxLabels) {\n\t\t\t\t<div [auUse]=\"widget.directives.minLabelDirective\">\n\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.min}\"></ng-template>\n\t\t\t\t</div>\n\t\t\t\t<div [auUse]=\"widget.directives.maxLabelDirective\">\n\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.max}\"></ng-template>\n\t\t\t\t</div>\n\t\t\t}\n\t\t\t@if (state.showValueLabels && state.combinedLabelDisplay) {\n\t\t\t\t<div [auUse]=\"widget.directives.combinedHandleLabelDisplayDirective\">\n\t\t\t\t\t@if (state.rtl) {\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.sortedValues[1]}\"></ng-template> -\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.sortedValues[0]}\"></ng-template>\n\t\t\t\t\t} @else {\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.sortedValues[0]}\"></ng-template> -\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.sortedValues[1]}\"></ng-template>\n\t\t\t\t\t}\n\t\t\t\t</div>\n\t\t\t}\n\t\t\t@for (item of state.sortedHandles; track item.id; let i = $index) {\n\t\t\t\t<ng-template [auSlot]=\"state.handle\" [auSlotProps]=\"{state, widget, item}\"></ng-template>\n\t\t\t\t@if (state.showValueLabels && !state.combinedLabelDisplay) {\n\t\t\t\t\t<div [auUse]=\"[widget.directives.handleLabelDisplayDirective, {index: i}]\">\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.values[i]}\"></ng-template>\n\t\t\t\t\t</div>\n\t\t\t\t}\n\t\t\t}\n\t\t</ng-template>\n\t`,\n})\nexport class SliderDefaultStructureSlotComponent {\n\t@ViewChild('structure', {static: true}) structure!: TemplateRef<SliderContext>;\n}\n\nexport const sliderDefaultSlotStructure = new ComponentTemplate(SliderDefaultStructureSlotComponent, 'structure');\n\nexport type PartialSliderProps = Partial<SliderProps>;\nconst defaultConfig: PartialSliderProps = {\n\tstructure: sliderDefaultSlotStructure,\n\thandle: sliderDefaultSlotHandle,\n};\n\n@Component({\n\tselector: '[auSlider]',\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\tencapsulation: ViewEncapsulation.None,\n\tproviders: [{provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => SliderComponent), multi: true}],\n\timports: [SlotDirective],\n\thost: {\n\t\t'(blur)': 'handleBlur()',\n\t},\n\ttemplate: ` <ng-template [auSlot]=\"state().structure\" [auSlotProps]=\"{state: state(), widget}\"></ng-template> `,\n})\nexport class SliderComponent extends BaseWidgetDirective<SliderWidget> implements AfterContentChecked {\n\treadonly defaultSlots: WritableSignal<PartialSliderProps> = writable(defaultConfig);\n\n\treadonly _widget = callWidgetFactory({\n\t\tfactory: createSlider,\n\t\twidgetName: 'slider',\n\t\tdefaultConfig: this.defaultSlots,\n\t\tevents: {\n\t\t\tonValuesChange: (event) => {\n\t\t\t\tthis.onChange(event);\n\t\t\t\tthis.onTouched();\n\t\t\t\tthis.valuesChange.emit(event);\n\t\t\t},\n\t\t},\n\t\tafterInit: () => {\n\t\t\tuseDirectiveForHost(this._widget.directives.sliderDirective);\n\t\t},\n\t});\n\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t */\n\t@Input('auClassName') className: string | undefined;\n\n\t/**\n\t * Minimum value that can be assigned to the slider\n\t */\n\t@Input({alias: 'auMin', transform: auNumberAttribute})\n\tmin: number | undefined;\n\n\t/**\n\t * Maximum value that can be assigned to the slider\n\t */\n\t@Input({alias: 'auMax', transform: auNumberAttribute})\n\tmax: number | undefined;\n\n\t/**\n\t * Unit value between slider steps\n\t */\n\t@Input({alias: 'auStepSize', transform: auNumberAttribute})\n\tstepSize: number | undefined;\n\n\t/**\n\t * Current slider values\n\t */\n\t@Input('auValues')\n\tvalues: number[] | undefined;\n\n\t/**\n\t * It `true` slider display is inversed\n\t */\n\t@Input({alias: 'auRtl', transform: auBooleanAttribute})\n\trtl: boolean | undefined;\n\n\t/**\n\t * If `true` the value labels are displayed on the slider\n\t */\n\t@Input({alias: 'auShowValueLabels', transform: auBooleanAttribute}) showValueLabels: boolean | undefined;\n\n\t/**\n\t * If `true` the min and max labels are displayed on the slider\n\t */\n\t@Input({alias: 'auShowMinMaxLabels', transform: auBooleanAttribute}) showMinMaxLabels: boolean | undefined;\n\t/**\n\t * Return the value for the 'aria-label' attribute for the handle\n\t */\n\t@Input('auAriaLabelHandle') ariaLabelHandle: ((value: number, sortedIndex: number, index: number) => string) | undefined;\n\t/**\n\t * Return the value for the 'aria-valuetext' attribute for the handle\n\t */\n\t@Input('auAriaValueText') ariaValueText: ((value: number, sortedIndex: number, index: number) => string) | undefined;\n\n\t/**\n\t * If `true` slider value cannot be changed but the slider is still focusable\n\t */\n\t@Input({alias: 'auReadonly', transform: auBooleanAttribute})\n\treadonly: boolean | undefined;\n\n\t/**\n\t * If `true` slider value cannot be changed and the slider cannot be focused\n\t */\n\t@Input({alias: 'auDisabled', transform: auBooleanAttribute})\n\tdisabled: boolean | undefined;\n\n\t/**\n\t * If `true` is vertically positioned otherwise it is horizontal\n\t */\n\t@Input({alias: 'auVertical', transform: auBooleanAttribute})\n\tvertical: boolean | undefined;\n\n\t/**\n\t * An event emitted when slider values are changed\n\t *\n\t * Event payload equals to the updated slider values\n\t */\n\t@Output('auValuesChange')\n\tvaluesChange = new EventEmitter<number[]>();\n\n\t/**\n\t * Slot to change the default labels of the slider\n\t */\n\t@Input('auLabel') label: SlotContent<SliderSlotLabelContext>;\n\t@ContentChild(SliderLabelDirective, {static: false}) slotLabelFromContent: SliderLabelDirective | undefined;\n\n\t/**\n\t * Slot to change the default display of the slider\n\t */\n\t@Input('auStructure') structure: SlotContent<SliderContext>;\n\t@ContentChild(SliderStructureDirective, {static: false}) slotStructureFromContent: SliderStructureDirective | undefined;\n\n\t/**\n\t * Slot to change the handlers\n\t */\n\t@Input('auHandle') handle: SlotContent<SliderSlotHandleContext>;\n\t@ContentChild(SliderHandleDirective, {static: false}) slotHandleFromContent: SliderHandleDirective | undefined;\n\n\t/**\n\t * Control value accessor methods\n\t */\n\tonChange = (_: any) => {};\n\n\tonTouched = () => {};\n\n\tregisterOnChange(fn: (value: any) => any): void {\n\t\tthis.onChange = fn;\n\t}\n\n\tregisterOnTouched(fn: () => any): void {\n\t\tthis.onTouched = fn;\n\t}\n\n\twriteValue(value: any): void {\n\t\tif (Array.isArray(value)) {\n\t\t\tthis._widget.patch({\n\t\t\t\tvalues: value,\n\t\t\t});\n\t\t} else {\n\t\t\tthis._widget.patch({\n\t\t\t\tvalues: [value],\n\t\t\t});\n\t\t}\n\t}\n\n\tsetDisabledState(isDisabled: boolean) {\n\t\tthis._widget.patch({\n\t\t\tdisabled: isDisabled,\n\t\t});\n\t}\n\n\thandleBlur() {\n\t\tthis.onTouched();\n\t}\n\n\tngAfterContentChecked(): void {\n\t\tthis._widget.patchSlots({\n\t\t\tstructure: this.slotStructureFromContent?.templateRef,\n\t\t\thandle: this.slotHandleFromContent?.templateRef,\n\t\t\tlabel: this.slotLabelFromContent?.templateRef,\n\t\t});\n\t}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider.component.js","sourceRoot":"","sources":["../../../../src/components/slider/slider.component.ts"],"names":[],"mappings":"AACA,OAAO,EACN,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,GACnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAsB,QAAQ,EAAC,MAAM,yBAAyB,CAAC;AAEtE,OAAO,EACN,uBAAuB,EACvB,SAAS,EACT,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,KAAK,EACL,MAAM,EACN,MAAM,EACN,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,UAAU,EACV,MAAM,GACN,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAC,IAAI,EAAC,MAAM,MAAM,CAAC;AAC1B,OAAO,EAAC,iBAAiB,EAAC,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;;;;;;IAwBvC,iCAA8D;IAAA,sBAAM;IAAA,iBAAS;;;;IAArE,6HAAqD;;;;;;;;;IAkC5D,yBAA4E;;;;IAAvE,wIAAgE;;;;;IAIrE,8BAAmD;IAClD,gIAAsF;IACvF,iBAAM;IACN,8BAAmD;IAClD,gIAAsF;IACvF,iBAAM;;;;;IALD,8DAA6C;IACpC,cAAsB;IAAC,AAAvB,uCAAsB,8EAAkD;IAEjF,cAA6C;IAA7C,8DAA6C;IACpC,cAAsB;IAAC,AAAvB,uCAAsB,+EAAkD;;;;;IAMpF,8IAAkG;IAAe,mBACjH;IAAA,8IAAkG;;;;;IAD9D,AAAvB,uCAAsB,0FAA8D;IACpF,eAAsB;IAAC,AAAvB,uCAAsB,0FAA8D;;;;;IAEjG,8IAAkG;IAAe,mBACjH;IAAA,8IAAkG;;;;;IAD9D,AAAvB,uCAAsB,0FAA8D;IACpF,eAAsB;IAAC,AAAvB,uCAAsB,0FAA8D;;;IANnG,8BAAqE;IAIlE,AAHF,+GAAiB,kGAGR;IAIV,iBAAM;;;;;IARD,gFAA+D;IACnE,cAMC;IAND,sCAMC;;;;;IAMD,8BAA2E;IAC1E,sIAA4F;IAC7F,iBAAM;;;;;;IAFD,+IAAqE;IAC5D,cAAsB;IAAC,AAAvB,uCAAsB,gGAAwD;;;IAF7F,AADA,wHAA2E,oGACf;;;;;;IADvB,AAAxB,wCAAuB,yEAAsC;IAC1E,cAIC;IAJD,qFAIC;;;IA7BF,sIAEC;IACD,yBAA8D;IAS9D,AARA,iGAA8B,6FAQ6B;IAW3D,sHAOC;;;;IA9BD,8CAEC;IACI,eAAkD;IAAlD,mEAAkD;IACvD,cAOC;IAPD,oDAOC;IACD,cAUC;IAVD,oFAUC;IACD,cAOC;IAPD,qCAOC;;;;;AApFJ,MAAM,OAAO,oBAAoB;IADjC;QAEQ,gBAAW,GAAG,MAAM,CAAC,CAAA,WAAmC,CAAA,CAAC,CAAC;KAIjE;IAHA,MAAM,CAAC,sBAAsB,CAAC,IAA0B,EAAE,OAAgB;QACzE,OAAO,IAAI,CAAC;IACb,CAAC;qFAJW,oBAAoB;oEAApB,oBAAoB;;iFAApB,oBAAoB;cADhC,SAAS;eAAC,EAAC,QAAQ,EAAE,4BAA4B,EAAE,UAAU,EAAE,IAAI,EAAC;;AASrE,MAAM,OAAO,qBAAqB;IADlC;QAEQ,gBAAW,GAAG,MAAM,CAAC,CAAA,WAAmC,CAAA,CAAC,CAAC;KAIjE;IAHA,MAAM,CAAC,sBAAsB,CAAC,IAA2B,EAAE,OAAgB;QAC1E,OAAO,IAAI,CAAC;IACb,CAAC;sFAJW,qBAAqB;oEAArB,qBAAqB;;iFAArB,qBAAqB;cADjC,SAAS;eAAC,EAAC,QAAQ,EAAE,6BAA6B,EAAE,UAAU,EAAE,IAAI,EAAC;;AAkBtE,MAAM,OAAO,gCAAgC;IAV7C;QAWkB,UAAK,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;KAUxC;IANA,SAAS,CAAC,KAAoB,EAAE,QAAgB,EAAE,iBAAmE;QACpH,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACnC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAC/C,KAAK,CAAC,MAAsB,CAAC,KAAK,EAAE,CAAC;QACvC,CAAC,CAAC,CAAC;IACJ,CAAC;iGAVW,gCAAgC;oEAAhC,gCAAgC;;;;;;YAL3C,+HAA0F;4BAFjF,YAAY,EAVV,qBAAqB;;iFAiBrB,gCAAgC;cAV5C,SAAS;eAAC;gBACV,UAAU,EAAE,IAAI;gBAChB,eAAe,EAAE,uBAAuB,CAAC,MAAM;gBAC/C,OAAO,EAAE,CAAC,YAAY,EAAE,qBAAqB,CAAC;gBAC9C,QAAQ,EAAE;;;;EAIT;aACD;gBAI8C,MAAM;kBAAnD,SAAS;mBAAC,QAAQ,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC;;kFAHvB,gCAAgC;AAa7C,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,iBAAiB,CAAC,gCAAgC,EAAE,QAAQ,CAAC,CAAC;AAGzG,MAAM,OAAO,wBAAwB;IADrC;QAEQ,gBAAW,GAAG,MAAM,CAAC,CAAA,WAAoC,CAAA,CAAC,CAAC;KAIlE;IAHA,MAAM,CAAC,sBAAsB,CAAC,IAA8B,EAAE,OAAgB;QAC7E,OAAO,IAAI,CAAC;IACb,CAAC;yFAJW,wBAAwB;oEAAxB,wBAAwB;;iFAAxB,wBAAwB;cADpC,SAAS;eAAC,EAAC,QAAQ,EAAE,gCAAgC,EAAE,UAAU,EAAE,IAAI,EAAC;;AAgDzE,MAAM,OAAO,mCAAmC;oGAAnC,mCAAmC;oEAAnC,mCAAmC;;;;;;YAnC9C,kIAAgF;4BAFvE,aAAa,EAVX,wBAAwB,EAUe,YAAY;;iFAqCnD,mCAAmC;cAxC/C,SAAS;eAAC;gBACV,UAAU,EAAE,IAAI;gBAChB,eAAe,EAAE,uBAAuB,CAAC,MAAM;gBAC/C,OAAO,EAAE,CAAC,aAAa,EAAE,wBAAwB,EAAE,YAAY,CAAC;gBAChE,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCT;aACD;gBAEwC,SAAS;kBAAhD,SAAS;mBAAC,WAAW,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC;;kFAD1B,mCAAmC;AAIhD,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAI,iBAAiB,CAAC,mCAAmC,EAAE,WAAW,CAAC,CAAC;AAGlH,MAAM,aAAa,GAAuB;IACzC,SAAS,EAAE,0BAA0B;IACrC,MAAM,EAAE,uBAAuB;CAC/B,CAAC;AAcF,MAAM,OAAO,eAAgB,SAAQ,mBAAiC;IAZtE;;QAaU,iBAAY,GAAuC,QAAQ,CAAC,aAAa,CAAC,CAAC;QAE3E,YAAO,GAAG,iBAAiB,CAAC;YACpC,OAAO,EAAE,YAAY;YACrB,UAAU,EAAE,QAAQ;YACpB,aAAa,EAAE,IAAI,CAAC,YAAY;YAChC,MAAM,EAAE;gBACP,cAAc,EAAE,CAAC,KAAK,EAAE,EAAE;oBACzB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;oBACrB,IAAI,CAAC,SAAS,EAAE,CAAC;oBACjB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC/B,CAAC;aACD;YACD,SAAS,EAAE,GAAG,EAAE;gBACf,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;YAC9D,CAAC;SACD,CAAC,CAAC;QAiHH;;;;;;;;;WASG;QAEH,iBAAY,GAAG,IAAI,YAAY,EAAY,CAAC;QAyB5C;;WAEG;QACH,aAAQ,GAAG,CAAC,CAAM,EAAE,EAAE,GAAE,CAAC,CAAC;QAE1B,cAAS,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;KAuCrB;IArCA,gBAAgB,CAAC,EAAuB;QACvC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,iBAAiB,CAAC,EAAa;QAC9B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,UAAU,CAAC,KAAU;QACpB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;gBAClB,MAAM,EAAE,KAAK;aACb,CAAC,CAAC;QACJ,CAAC;aAAM,CAAC;YACP,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;gBAClB,MAAM,EAAE,CAAC,KAAK,CAAC;aACf,CAAC,CAAC;QACJ,CAAC;IACF,CAAC;IAED,gBAAgB,CAAC,UAAmB;QACnC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;YAClB,QAAQ,EAAE,UAAU;SACpB,CAAC,CAAC;IACJ,CAAC;IAED,UAAU;QACT,IAAI,CAAC,SAAS,EAAE,CAAC;IAClB,CAAC;IAED,qBAAqB;QACpB,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;YACvB,SAAS,EAAE,IAAI,CAAC,wBAAwB,EAAE,WAAW;YACrD,MAAM,EAAE,IAAI,CAAC,qBAAqB,EAAE,WAAW;YAC/C,KAAK,EAAE,IAAI,CAAC,oBAAoB,EAAE,WAAW;SAC7C,CAAC,CAAC;IACJ,CAAC;gOAjNW,eAAe,SAAf,eAAe;oEAAf,eAAe;wCAwJb,oBAAoB;wCAMpB,wBAAwB;wCAMxB,qBAAqB;;;;;;;YApKvB,kFAAA,gBAAY,IAAG;4FA+BQ,iBAAiB,4BAQjB,iBAAiB,2CAQZ,iBAAiB,+DAgBtB,kBAAkB,gEAQN,kBAAkB,mEAOjB,kBAAkB,iKAiC1B,kBAAkB,2CAQlB,kBAAkB,2CAQlB,kBAAkB,oNAtI/C,CAAC,EAAC,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC;YAK1F,gFAAmF;;YAAzC,AAA7B,8CAA4B,oEAAyC;4BAJpF,aAAa;;iFAMX,eAAe;cAZ3B,SAAS;eAAC;gBACV,QAAQ,EAAE,YAAY;gBACtB,UAAU,EAAE,IAAI;gBAChB,eAAe,EAAE,uBAAuB,CAAC,MAAM;gBAC/C,aAAa,EAAE,iBAAiB,CAAC,IAAI;gBACrC,SAAS,EAAE,CAAC,EAAC,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,gBAAgB,CAAC,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC;gBACtG,OAAO,EAAE,CAAC,aAAa,CAAC;gBACxB,IAAI,EAAE;oBACL,QAAQ,EAAE,cAAc;iBACxB;gBACD,QAAQ,EAAE,qGAAqG;aAC/G;gBAyBsB,SAAS;kBAA9B,KAAK;mBAAC,aAAa;YAQpB,GAAG;kBADF,KAAK;mBAAC,EAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAC;YASrD,GAAG;kBADF,KAAK;mBAAC,EAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAC;YASrD,QAAQ;kBADP,KAAK;mBAAC,EAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,iBAAiB,EAAC;YAS1D,MAAM;kBADL,KAAK;mBAAC,UAAU;YASjB,GAAG;kBADF,KAAK;mBAAC,EAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAC;YAQc,eAAe;kBAAlF,KAAK;mBAAC,EAAC,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,kBAAkB,EAAC;YAOG,gBAAgB;kBAApF,KAAK;mBAAC,EAAC,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,kBAAkB,EAAC;YAavC,eAAe;kBAA1C,KAAK;mBAAC,mBAAmB;YAaA,aAAa;kBAAtC,KAAK;mBAAC,iBAAiB;YAQxB,QAAQ;kBADP,KAAK;mBAAC,EAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,kBAAkB,EAAC;YAS3D,QAAQ;kBADP,KAAK;mBAAC,EAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,kBAAkB,EAAC;YAS3D,QAAQ;kBADP,KAAK;mBAAC,EAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,kBAAkB,EAAC;YAc3D,YAAY;kBADX,MAAM;mBAAC,gBAAgB;YAWN,KAAK;kBAAtB,KAAK;mBAAC,SAAS;YACqC,oBAAoB;kBAAxE,YAAY;mBAAC,oBAAoB,EAAE,EAAC,MAAM,EAAE,KAAK,EAAC;YAK7B,SAAS;kBAA9B,KAAK;mBAAC,aAAa;YACqC,wBAAwB;kBAAhF,YAAY;mBAAC,wBAAwB,EAAE,EAAC,MAAM,EAAE,KAAK,EAAC;YAKpC,MAAM;kBAAxB,KAAK;mBAAC,UAAU;YACqC,qBAAqB;kBAA1E,YAAY;mBAAC,qBAAqB,EAAE,EAAC,MAAM,EAAE,KAAK,EAAC;;kFApKxC,eAAe","sourcesContent":["import type {SlotContent} from '@agnos-ui/angular-headless';\nimport {\n\tBaseWidgetDirective,\n\tComponentTemplate,\n\tSlotDirective,\n\tUseDirective,\n\tauBooleanAttribute,\n\tauNumberAttribute,\n\tuseDirectiveForHost,\n} from '@agnos-ui/angular-headless';\nimport {type WritableSignal, writable} from '@amadeus-it-group/tansu';\nimport type {AfterContentChecked} from '@angular/core';\nimport {\n\tChangeDetectionStrategy,\n\tComponent,\n\tContentChild,\n\tDirective,\n\tEventEmitter,\n\tInput,\n\tNgZone,\n\tOutput,\n\tTemplateRef,\n\tViewChild,\n\tViewEncapsulation,\n\tforwardRef,\n\tinject,\n} from '@angular/core';\nimport {NG_VALUE_ACCESSOR} from '@angular/forms';\nimport {take} from 'rxjs';\nimport {callWidgetFactory} from '../../config';\nimport type {SliderContext, SliderProps, SliderSlotHandleContext, SliderSlotLabelContext, SliderWidget} from './slider.gen';\nimport {createSlider} from './slider.gen';\n\n@Directive({selector: 'ng-template[auSliderLabel]', standalone: true})\nexport class SliderLabelDirective {\n\tpublic templateRef = inject(TemplateRef<SliderSlotLabelContext>);\n\tstatic ngTemplateContextGuard(_dir: SliderLabelDirective, context: unknown): context is SliderSlotLabelContext {\n\t\treturn true;\n\t}\n}\n\n@Directive({selector: 'ng-template[auSliderHandle]', standalone: true})\nexport class SliderHandleDirective {\n\tpublic templateRef = inject(TemplateRef<SliderSlotLabelContext>);\n\tstatic ngTemplateContextGuard(_dir: SliderHandleDirective, context: unknown): context is SliderSlotHandleContext {\n\t\treturn true;\n\t}\n}\n\n@Component({\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [UseDirective, SliderHandleDirective],\n\ttemplate: `\n\t\t<ng-template auSliderHandle #handle let-state=\"state\" let-widget=\"widget\" let-item=\"item\">\n\t\t\t<button [auUse]=\"[widget.directives.handleDirective, {item}]\">&nbsp;</button>\n\t\t</ng-template>\n\t`,\n})\nexport class SliderDefaultHandleSlotComponent {\n\tprivate readonly _zone = inject(NgZone);\n\n\t@ViewChild('handle', {static: true}) readonly handle!: TemplateRef<SliderSlotHandleContext>;\n\n\tonKeyDown(event: KeyboardEvent, handleId: number, widgetOnKeyDownFn: (event: KeyboardEvent, handleId: number) => void) {\n\t\twidgetOnKeyDownFn(event, handleId);\n\t\tthis._zone.onStable.pipe(take(1)).subscribe(() => {\n\t\t\t(event.target as HTMLElement).focus();\n\t\t});\n\t}\n}\n\nexport const sliderDefaultSlotHandle = new ComponentTemplate(SliderDefaultHandleSlotComponent, 'handle');\n\n@Directive({selector: 'ng-template[auSliderStructure]', standalone: true})\nexport class SliderStructureDirective {\n\tpublic templateRef = inject(TemplateRef<SliderSlotHandleContext>);\n\tstatic ngTemplateContextGuard(_dir: SliderStructureDirective, context: unknown): context is SliderSlotHandleContext {\n\t\treturn true;\n\t}\n}\n\n@Component({\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [SlotDirective, SliderStructureDirective, UseDirective],\n\ttemplate: `\n\t\t<ng-template auSliderStructure #structure let-state=\"state\" let-widget=\"widget\">\n\t\t\t@for (option of state.progressDisplayOptions; track option) {\n\t\t\t\t<div [auUse]=\"[widget.directives.progressDisplayDirective, {option}]\"></div>\n\t\t\t}\n\t\t\t<div [auUse]=\"widget.directives.clickableAreaDirective\"></div>\n\t\t\t@if (state.showMinMaxLabels) {\n\t\t\t\t<div [auUse]=\"widget.directives.minLabelDirective\">\n\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.min}\"></ng-template>\n\t\t\t\t</div>\n\t\t\t\t<div [auUse]=\"widget.directives.maxLabelDirective\">\n\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.max}\"></ng-template>\n\t\t\t\t</div>\n\t\t\t}\n\t\t\t@if (state.showValueLabels && state.combinedLabelDisplay) {\n\t\t\t\t<div [auUse]=\"widget.directives.combinedHandleLabelDisplayDirective\">\n\t\t\t\t\t@if (state.rtl) {\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.sortedValues[1]}\"></ng-template> -\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.sortedValues[0]}\"></ng-template>\n\t\t\t\t\t} @else {\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.sortedValues[0]}\"></ng-template> -\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.sortedValues[1]}\"></ng-template>\n\t\t\t\t\t}\n\t\t\t\t</div>\n\t\t\t}\n\t\t\t@for (item of state.sortedHandles; track item.id; let i = $index) {\n\t\t\t\t<ng-template [auSlot]=\"state.handle\" [auSlotProps]=\"{state, widget, item}\"></ng-template>\n\t\t\t\t@if (state.showValueLabels && !state.combinedLabelDisplay) {\n\t\t\t\t\t<div [auUse]=\"[widget.directives.handleLabelDisplayDirective, {index: i}]\">\n\t\t\t\t\t\t<ng-template [auSlot]=\"state.label\" [auSlotProps]=\"{state, widget, value: state.values[i]}\"></ng-template>\n\t\t\t\t\t</div>\n\t\t\t\t}\n\t\t\t}\n\t\t</ng-template>\n\t`,\n})\nexport class SliderDefaultStructureSlotComponent {\n\t@ViewChild('structure', {static: true}) structure!: TemplateRef<SliderContext>;\n}\n\nexport const sliderDefaultSlotStructure = new ComponentTemplate(SliderDefaultStructureSlotComponent, 'structure');\n\nexport type PartialSliderProps = Partial<SliderProps>;\nconst defaultConfig: PartialSliderProps = {\n\tstructure: sliderDefaultSlotStructure,\n\thandle: sliderDefaultSlotHandle,\n};\n\n@Component({\n\tselector: '[auSlider]',\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\tencapsulation: ViewEncapsulation.None,\n\tproviders: [{provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => SliderComponent), multi: true}],\n\timports: [SlotDirective],\n\thost: {\n\t\t'(blur)': 'handleBlur()',\n\t},\n\ttemplate: ` <ng-template [auSlot]=\"state().structure\" [auSlotProps]=\"{state: state(), widget}\"></ng-template> `,\n})\nexport class SliderComponent extends BaseWidgetDirective<SliderWidget> implements AfterContentChecked {\n\treadonly defaultSlots: WritableSignal<PartialSliderProps> = writable(defaultConfig);\n\n\treadonly _widget = callWidgetFactory({\n\t\tfactory: createSlider,\n\t\twidgetName: 'slider',\n\t\tdefaultConfig: this.defaultSlots,\n\t\tevents: {\n\t\t\tonValuesChange: (event) => {\n\t\t\t\tthis.onChange(event);\n\t\t\t\tthis.onTouched();\n\t\t\t\tthis.valuesChange.emit(event);\n\t\t\t},\n\t\t},\n\t\tafterInit: () => {\n\t\t\tuseDirectiveForHost(this._widget.directives.sliderDirective);\n\t\t},\n\t});\n\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t *\n\t * @defaultValue `''`\n\t */\n\t@Input('auClassName') className: string | undefined;\n\n\t/**\n\t * Minimum value that can be assigned to the slider\n\t *\n\t * @defaultValue `0`\n\t */\n\t@Input({alias: 'auMin', transform: auNumberAttribute})\n\tmin: number | undefined;\n\n\t/**\n\t * Maximum value that can be assigned to the slider\n\t *\n\t * @defaultValue `100`\n\t */\n\t@Input({alias: 'auMax', transform: auNumberAttribute})\n\tmax: number | undefined;\n\n\t/**\n\t * Unit value between slider steps\n\t *\n\t * @defaultValue `1`\n\t */\n\t@Input({alias: 'auStepSize', transform: auNumberAttribute})\n\tstepSize: number | undefined;\n\n\t/**\n\t * Current slider values\n\t *\n\t * @defaultValue `[0]`\n\t */\n\t@Input('auValues')\n\tvalues: number[] | undefined;\n\n\t/**\n\t * It `true` slider display is inversed\n\t *\n\t * @defaultValue `false`\n\t */\n\t@Input({alias: 'auRtl', transform: auBooleanAttribute})\n\trtl: boolean | undefined;\n\n\t/**\n\t * If `true` the value labels are displayed on the slider\n\t *\n\t * @defaultValue `true`\n\t */\n\t@Input({alias: 'auShowValueLabels', transform: auBooleanAttribute}) showValueLabels: boolean | undefined;\n\n\t/**\n\t * If `true` the min and max labels are displayed on the slider\n\t *\n\t * @defaultValue `true`\n\t */\n\t@Input({alias: 'auShowMinMaxLabels', transform: auBooleanAttribute}) showMinMaxLabels: boolean | undefined;\n\n\t/**\n\t * Return the value for the 'aria-label' attribute for the handle\n\t * @param value - value of the handle\n\t * @param sortedIndex - index of the handle in the sorted list\n\t * @param index - index of the handle in the original list\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * (value: number) => '' + value\n\t * ```\n\t */\n\t@Input('auAriaLabelHandle') ariaLabelHandle: ((value: number, sortedIndex: number, index: number) => string) | undefined;\n\n\t/**\n\t * Return the value for the 'aria-valuetext' attribute for the handle\n\t * @param value - value of the handle\n\t * @param sortedIndex - index of the handle in the sorted list\n\t * @param index - index of the handle in the original list\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * (value: number) => '' + value\n\t * ```\n\t */\n\t@Input('auAriaValueText') ariaValueText: ((value: number, sortedIndex: number, index: number) => string) | undefined;\n\n\t/**\n\t * If `true` slider value cannot be changed but the slider is still focusable\n\t *\n\t * @defaultValue `false`\n\t */\n\t@Input({alias: 'auReadonly', transform: auBooleanAttribute})\n\treadonly: boolean | undefined;\n\n\t/**\n\t * If `true` slider value cannot be changed and the slider cannot be focused\n\t *\n\t * @defaultValue `false`\n\t */\n\t@Input({alias: 'auDisabled', transform: auBooleanAttribute})\n\tdisabled: boolean | undefined;\n\n\t/**\n\t * If `true` is vertically positioned otherwise it is horizontal\n\t *\n\t * @defaultValue `false`\n\t */\n\t@Input({alias: 'auVertical', transform: auBooleanAttribute})\n\tvertical: boolean | undefined;\n\n\t/**\n\t * An event emitted when slider values are changed\n\t *\n\t * Event payload equals to the updated slider values\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\t@Output('auValuesChange')\n\tvaluesChange = new EventEmitter<number[]>();\n\n\t/**\n\t * Slot to change the default labels of the slider\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ({value}: SliderSlotLabelContext) => '' + value\n\t * ```\n\t */\n\t@Input('auLabel') label: SlotContent<SliderSlotLabelContext>;\n\t@ContentChild(SliderLabelDirective, {static: false}) slotLabelFromContent: SliderLabelDirective | undefined;\n\n\t/**\n\t * Slot to change the default display of the slider\n\t */\n\t@Input('auStructure') structure: SlotContent<SliderContext>;\n\t@ContentChild(SliderStructureDirective, {static: false}) slotStructureFromContent: SliderStructureDirective | undefined;\n\n\t/**\n\t * Slot to change the handlers\n\t */\n\t@Input('auHandle') handle: SlotContent<SliderSlotHandleContext>;\n\t@ContentChild(SliderHandleDirective, {static: false}) slotHandleFromContent: SliderHandleDirective | undefined;\n\n\t/**\n\t * Control value accessor methods\n\t */\n\tonChange = (_: any) => {};\n\n\tonTouched = () => {};\n\n\tregisterOnChange(fn: (value: any) => any): void {\n\t\tthis.onChange = fn;\n\t}\n\n\tregisterOnTouched(fn: () => any): void {\n\t\tthis.onTouched = fn;\n\t}\n\n\twriteValue(value: any): void {\n\t\tif (Array.isArray(value)) {\n\t\t\tthis._widget.patch({\n\t\t\t\tvalues: value,\n\t\t\t});\n\t\t} else {\n\t\t\tthis._widget.patch({\n\t\t\t\tvalues: [value],\n\t\t\t});\n\t\t}\n\t}\n\n\tsetDisabledState(isDisabled: boolean) {\n\t\tthis._widget.patch({\n\t\t\tdisabled: isDisabled,\n\t\t});\n\t}\n\n\thandleBlur() {\n\t\tthis.onTouched();\n\t}\n\n\tngAfterContentChecked(): void {\n\t\tthis._widget.patchSlots({\n\t\t\tstructure: this.slotStructureFromContent?.templateRef,\n\t\t\thandle: this.slotHandleFromContent?.templateRef,\n\t\t\tlabel: this.slotLabelFromContent?.templateRef,\n\t\t});\n\t}\n}\n"]}

package/esm2022/components/slider/slider.gen.mjs

@@ -1,2 +1,15 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider.gen.js","sourceRoot":"","sources":["../../../../src/components/slider/slider.gen.ts"],"names":[],"mappings":"","sourcesContent":["import type {WidgetSlotContext, SlotContent, Widget, Directive} from '@agnos-ui/angular-headless';\n\nexport type SliderContext = WidgetSlotContext<SliderWidget>;\n\nexport type SliderSlotLabelContext = SliderContext & {value: number};\n\nexport type SliderSlotHandleContext = SliderContext & {item: SliderHandle};\n\nexport interface SliderState {\n\t/**\n\t * Sorted slider values\n\t */\n\tsortedValues: number[];\n\t/**\n\t * Combined label left offset in %\n\t */\n\tcombinedLabelPositionLeft: number;\n\t/**\n\t * Combined label top offset in %\n\t */\n\tcombinedLabelPositionTop: number;\n\t/**\n\t * If true, the minimum label will be visible\n\t */\n\tminValueLabelDisplay: boolean;\n\t/**\n\t * If true, the maximum label will be visible\n\t */\n\tmaxValueLabelDisplay: boolean;\n\t/**\n\t * If true, the label when the handles are close is visible\n\t */\n\tcombinedLabelDisplay: boolean;\n\t/**\n\t * Array of the sorted handles to display\n\t */\n\tsortedHandles: SliderHandle[];\n\t/**\n\t * Array of objects representing progress display options\n\t */\n\tprogressDisplayOptions: ProgressDisplayOptions[];\n\t/**\n\t * Array of objects representing handle display options\n\t */\n\thandleDisplayOptions: HandleDisplayOptions[];\n\t/**\n\t * Check if the slider is interactive, meaning it is not disabled or readonly\n\t */\n\tinteractive: boolean;\n\t/**\n\t * Minimum value that can be assigned to the slider\n\t */\n\tmin: number;\n\t/**\n\t * Maximum value that can be assigned to the slider\n\t */\n\tmax: number;\n\t/**\n\t * Unit value between slider steps\n\t */\n\tstepSize: number;\n\t/**\n\t * If `true` slider value cannot be changed but the slider is still focusable\n\t */\n\treadonly: boolean;\n\t/**\n\t * If `true` slider value cannot be changed and the slider cannot be focused\n\t */\n\tdisabled: boolean;\n\t/**\n\t * If `true` is vertically positioned otherwise it is horizontal\n\t */\n\tvertical: boolean;\n\t/**\n\t * Current slider values\n\t */\n\tvalues: number[];\n\t/**\n\t * If `true` the value labels are displayed on the slider\n\t */\n\tshowValueLabels: boolean;\n\t/**\n\t * If `true` the min and max labels are displayed on the slider\n\t */\n\tshowMinMaxLabels: boolean;\n\t/**\n\t * It `true` slider display is inversed\n\t */\n\trtl: boolean;\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t */\n\tclassName: string;\n\t/**\n\t * Slot to change the default display of the slider\n\t */\n\tstructure: SlotContent<SliderContext>;\n\t/**\n\t * Slot to change the default labels of the slider\n\t */\n\tlabel: SlotContent<SliderSlotLabelContext>;\n\t/**\n\t * Slot to change the handlers\n\t */\n\thandle: SlotContent<SliderSlotHandleContext>;\n}\n\nexport interface SliderProps {\n\t/**\n\t * Return the value for the 'aria-label' attribute for the handle\n\t */\n\tariaLabelHandle: (value: number, sortedIndex: number, index: number) => string;\n\t/**\n\t * Return the value for the 'aria-valuetext' attribute for the handle\n\t */\n\tariaValueText: (value: number, sortedIndex: number, index: number) => string;\n\t/**\n\t * An event emitted when slider values are changed\n\t * \n\t * Event payload equals to the updated slider values\n\t */\n\tonValuesChange: (values: number[]) => void;\n\t/**\n\t * Minimum value that can be assigned to the slider\n\t */\n\tmin: number;\n\t/**\n\t * Maximum value that can be assigned to the slider\n\t */\n\tmax: number;\n\t/**\n\t * Unit value between slider steps\n\t */\n\tstepSize: number;\n\t/**\n\t * If `true` slider value cannot be changed but the slider is still focusable\n\t */\n\treadonly: boolean;\n\t/**\n\t * If `true` slider value cannot be changed and the slider cannot be focused\n\t */\n\tdisabled: boolean;\n\t/**\n\t * If `true` is vertically positioned otherwise it is horizontal\n\t */\n\tvertical: boolean;\n\t/**\n\t * Current slider values\n\t */\n\tvalues: number[];\n\t/**\n\t * If `true` the value labels are displayed on the slider\n\t */\n\tshowValueLabels: boolean;\n\t/**\n\t * If `true` the min and max labels are displayed on the slider\n\t */\n\tshowMinMaxLabels: boolean;\n\t/**\n\t * It `true` slider display is inversed\n\t */\n\trtl: boolean;\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t */\n\tclassName: string;\n\t/**\n\t * Slot to change the default display of the slider\n\t */\n\tstructure: SlotContent<SliderContext>;\n\t/**\n\t * Slot to change the default labels of the slider\n\t */\n\tlabel: SlotContent<SliderSlotLabelContext>;\n\t/**\n\t * Slot to change the handlers\n\t */\n\thandle: SlotContent<SliderSlotHandleContext>;\n}\n\nexport type SliderWidget = Widget<SliderProps, SliderState, SliderApi, SliderActions, SliderDirectives>;\n\nexport interface ProgressDisplayOptions {\n\t/**\n\t * Right offset of the progress in %\n\t */\n\tleft: number | null;\n\t/**\n\t * Left offset of the progress in %\n\t */\n\tright: number | null;\n\t/**\n\t * Top offset of the progress in %\n\t */\n\ttop: number | null;\n\t/**\n\t * Bottom offset of the progress in %\n\t */\n\tbottom: number | null;\n\t/**\n\t * Width of the progress in %\n\t */\n\twidth: number;\n\t/**\n\t * Height of hte progress in %\n\t */\n\theight: number;\n}\n\nexport interface HandleDisplayOptions {\n\t/**\n\t * Left offset of the handle in %\n\t */\n\tleft: number | null;\n\t/**\n\t * Top offset of the handle in %\n\t */\n\ttop: number | null;\n}\n\nexport interface SliderHandle {\n\t/**\n\t * Value of the handle\n\t */\n\tvalue: number;\n\t/**\n\t * Handle id\n\t */\n\tid: number;\n\t/**\n\t * ariaLabel of the handle\n\t */\n\tariaLabel: string;\n\t/**\n\t * ariaValueText of the handle\n\t */\n\tariaValueText: string;\n}\n\nexport interface SliderApi {\n}\n\nexport interface SliderDirectives {\n\t/**\n\t * Directive to get the slider component elementRef\n\t */\n\tsliderDirective: Directive;\n\t/**\n\t * Directive used to style the progress display for each handle\n\t */\n\tprogressDisplayDirective: Directive<{option: ProgressDisplayOptions}>;\n\t/**\n\t * Directive to apply to the slider clickable area, to directly move the handle to a given specific position\n\t */\n\tclickableAreaDirective: Directive;\n\t/**\n\t * Directive to apply to the slider handle if any\n\t */\n\thandleDirective: Directive<{item: SliderHandle}>;\n\t/**\n\t * Directive to get the minLabel elementRef\n\t */\n\tminLabelDirective: Directive;\n\t/**\n\t * Directive to get the maxLabel elementRef\n\t */\n\tmaxLabelDirective: Directive;\n\t/**\n\t * Directive to apply to the handle when combined label display is active\n\t */\n\tcombinedHandleLabelDisplayDirective: Directive;\n\t/**\n\t * Directive to apply to the handle when combined label display is not active\n\t */\n\thandleLabelDisplayDirective: Directive<{index: number}>;\n}\n\nexport interface SliderActions {\n\t/**\n\t * Method to handle click on the slider\n\t */\n\tclick(event: MouseEvent): void;\n\t/**\n\t * Method to process the keyboard event\n\t */\n\tkeydown(event: KeyboardEvent, handleNumber: number): void;\n\t/**\n\t * Method describing the behavior of the slider handle on mouse down event\n\t */\n\tmouseDown(event: MouseEvent, handleId: number): void;\n\t/**\n\t * Method describing the behavior of the slider handle on touch start event\n\t */\n\ttouchStart(event: TouchEvent, handleId: number): void;\n}\n\n"]}
+import { getSliderDefaultConfig, createSlider } from '@agnos-ui/core-bootstrap/components/slider';
+/**
+ * Retrieve a shallow copy of the default Slider config
+ * @returns the default Slider config
+ */
+const export_getSliderDefaultConfig = getSliderDefaultConfig;
+export { export_getSliderDefaultConfig as getSliderDefaultConfig };
+/**
+ * Create a Slider with given config props
+ * @param config - an optional slider config
+ * @returns a SliderWidget
+ */
+const export_createSlider = createSlider;
+export { export_createSlider as createSlider };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider.gen.js","sourceRoot":"","sources":["../../../../src/components/slider/slider.gen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,sBAAsB,EAAE,YAAY,EAAC,MAAM,4CAA4C,CAAC;AAKhG;;;GAGG;AACH,MAAM,6BAA6B,GAAsB,sBAA6B,CAAC;AACvF,OAAO,EAAC,6BAA6B,IAAI,sBAAsB,EAAC,CAAC;AAmVjE;;;;GAIG;AAEH,MAAM,mBAAmB,GAAgC,YAAmB,CAAC;AAC7E,OAAO,EAAC,mBAAmB,IAAI,YAAY,EAAC,CAAC","sourcesContent":["import {getSliderDefaultConfig, createSlider} from '@agnos-ui/core-bootstrap/components/slider';\nimport type {WidgetSlotContext, SlotContent, Widget, WidgetFactory, Directive} from '@agnos-ui/angular-headless';\n\n\n\n/**\n * Retrieve a shallow copy of the default Slider config\n * @returns the default Slider config\n */\nconst export_getSliderDefaultConfig: () => SliderProps = getSliderDefaultConfig as any;\nexport {export_getSliderDefaultConfig as getSliderDefaultConfig};\n\n\n\nexport type SliderContext = WidgetSlotContext<SliderWidget>;\n\n\nexport type SliderSlotLabelContext = SliderContext & {value: number};\n\n\nexport type SliderSlotHandleContext = SliderContext & {item: SliderHandle};\n\nexport interface SliderState {\n\t\n\t/**\n\t * Sorted slider values\n\t */\n\tsortedValues: number[];\n\t\n\n\t/**\n\t * Combined label left offset in %\n\t */\n\tcombinedLabelPositionLeft: number;\n\t\n\n\t/**\n\t * Combined label top offset in %\n\t */\n\tcombinedLabelPositionTop: number;\n\t\n\n\t/**\n\t * If true, the minimum label will be visible\n\t */\n\tminValueLabelDisplay: boolean;\n\t\n\n\t/**\n\t * If true, the maximum label will be visible\n\t */\n\tmaxValueLabelDisplay: boolean;\n\t\n\n\t/**\n\t * If true, the label when the handles are close is visible\n\t */\n\tcombinedLabelDisplay: boolean;\n\t\n\n\t/**\n\t * Array of the sorted handles to display\n\t */\n\tsortedHandles: SliderHandle[];\n\t\n\n\t/**\n\t * Array of objects representing progress display options\n\t */\n\tprogressDisplayOptions: ProgressDisplayOptions[];\n\t\n\n\t/**\n\t * Array of objects representing handle display options\n\t */\n\thandleDisplayOptions: HandleDisplayOptions[];\n\t\n\n\t/**\n\t * Check if the slider is interactive, meaning it is not disabled or readonly\n\t */\n\tinteractive: boolean;\n\t\n\t/**\n\t * Minimum value that can be assigned to the slider\n\t *\n\t * @defaultValue `0`\n\t */\n\tmin: number;\n\t\n\n\t/**\n\t * Maximum value that can be assigned to the slider\n\t *\n\t * @defaultValue `100`\n\t */\n\tmax: number;\n\t\n\n\t/**\n\t * Unit value between slider steps\n\t *\n\t * @defaultValue `1`\n\t */\n\tstepSize: number;\n\t\n\n\t/**\n\t * If `true` slider value cannot be changed but the slider is still focusable\n\t *\n\t * @defaultValue `false`\n\t */\n\treadonly: boolean;\n\t\n\n\t/**\n\t * If `true` slider value cannot be changed and the slider cannot be focused\n\t *\n\t * @defaultValue `false`\n\t */\n\tdisabled: boolean;\n\t\n\n\t/**\n\t * If `true` is vertically positioned otherwise it is horizontal\n\t *\n\t * @defaultValue `false`\n\t */\n\tvertical: boolean;\n\t\n\n\t/**\n\t * Current slider values\n\t *\n\t * @defaultValue `[0]`\n\t */\n\tvalues: number[];\n\t\n\n\t/**\n\t * If `true` the value labels are displayed on the slider\n\t *\n\t * @defaultValue `true`\n\t */\n\tshowValueLabels: boolean;\n\t\n\n\t/**\n\t * If `true` the min and max labels are displayed on the slider\n\t *\n\t * @defaultValue `true`\n\t */\n\tshowMinMaxLabels: boolean;\n\t\n\n\t/**\n\t * It `true` slider display is inversed\n\t *\n\t * @defaultValue `false`\n\t */\n\trtl: boolean;\n\t\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t *\n\t * @defaultValue `''`\n\t */\n\tclassName: string;\n\t\n\t/**\n\t * Slot to change the default display of the slider\n\t */\n\tstructure: SlotContent<SliderContext>;\n\t\n\n\t/**\n\t * Slot to change the default labels of the slider\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ({value}: SliderSlotLabelContext) => '' + value\n\t * ```\n\t */\n\tlabel: SlotContent<SliderSlotLabelContext>;\n\t\n\n\t/**\n\t *  Slot to change the handlers\n\t */\n\thandle: SlotContent<SliderSlotHandleContext>;\n}\n\nexport interface SliderProps {\n\t\n\t/**\n\t * Return the value for the 'aria-label' attribute for the handle\n\t * @param value - value of the handle\n\t * @param sortedIndex - index of the handle in the sorted list\n\t * @param index - index of the handle in the original list\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * (value: number) => '' + value\n\t * ```\n\t */\n\tariaLabelHandle: (value: number, sortedIndex: number, index: number) => string;\n\t\n\n\t/**\n\t * Return the value for the 'aria-valuetext' attribute for the handle\n\t * @param value - value of the handle\n\t * @param sortedIndex - index of the handle in the sorted list\n\t * @param index - index of the handle in the original list\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * (value: number) => '' + value\n\t * ```\n\t */\n\tariaValueText: (value: number, sortedIndex: number, index: number) => string;\n\t\n\n\t/**\n\t * An event emitted when slider values are changed\n\t *\n\t * Event payload equals to the updated slider values\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\tonValuesChange: (values: number[]) => void;\n\t\n\t/**\n\t * Minimum value that can be assigned to the slider\n\t *\n\t * @defaultValue `0`\n\t */\n\tmin: number;\n\t\n\n\t/**\n\t * Maximum value that can be assigned to the slider\n\t *\n\t * @defaultValue `100`\n\t */\n\tmax: number;\n\t\n\n\t/**\n\t * Unit value between slider steps\n\t *\n\t * @defaultValue `1`\n\t */\n\tstepSize: number;\n\t\n\n\t/**\n\t * If `true` slider value cannot be changed but the slider is still focusable\n\t *\n\t * @defaultValue `false`\n\t */\n\treadonly: boolean;\n\t\n\n\t/**\n\t * If `true` slider value cannot be changed and the slider cannot be focused\n\t *\n\t * @defaultValue `false`\n\t */\n\tdisabled: boolean;\n\t\n\n\t/**\n\t * If `true` is vertically positioned otherwise it is horizontal\n\t *\n\t * @defaultValue `false`\n\t */\n\tvertical: boolean;\n\t\n\n\t/**\n\t * Current slider values\n\t *\n\t * @defaultValue `[0]`\n\t */\n\tvalues: number[];\n\t\n\n\t/**\n\t * If `true` the value labels are displayed on the slider\n\t *\n\t * @defaultValue `true`\n\t */\n\tshowValueLabels: boolean;\n\t\n\n\t/**\n\t * If `true` the min and max labels are displayed on the slider\n\t *\n\t * @defaultValue `true`\n\t */\n\tshowMinMaxLabels: boolean;\n\t\n\n\t/**\n\t * It `true` slider display is inversed\n\t *\n\t * @defaultValue `false`\n\t */\n\trtl: boolean;\n\t\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t *\n\t * @defaultValue `''`\n\t */\n\tclassName: string;\n\t\n\t/**\n\t * Slot to change the default display of the slider\n\t */\n\tstructure: SlotContent<SliderContext>;\n\t\n\n\t/**\n\t * Slot to change the default labels of the slider\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * ({value}: SliderSlotLabelContext) => '' + value\n\t * ```\n\t */\n\tlabel: SlotContent<SliderSlotLabelContext>;\n\t\n\n\t/**\n\t *  Slot to change the handlers\n\t */\n\thandle: SlotContent<SliderSlotHandleContext>;\n}\n\n\n\nexport type SliderWidget = Widget<SliderProps, SliderState, SliderApi, SliderActions, SliderDirectives>;\n\n\n\n/**\n * Create a Slider with given config props\n * @param config - an optional slider config\n * @returns a SliderWidget\n */\n\nconst export_createSlider: WidgetFactory<SliderWidget> = createSlider as any;\nexport {export_createSlider as createSlider};\n\nexport interface ProgressDisplayOptions {\n\t\n\t/**\n\t * Right offset of the progress in %\n\t */\n\tleft: number | null;\n\t\n\t/**\n\t * Left offset of the progress in %\n\t */\n\tright: number | null;\n\t\n\t/**\n\t * Top offset of the progress in %\n\t */\n\ttop: number | null;\n\t\n\t/**\n\t * Bottom offset of the progress in %\n\t */\n\tbottom: number | null;\n\t\n\t/**\n\t * Width of the progress in %\n\t */\n\twidth: number;\n\t\n\t/**\n\t * Height of hte progress in %\n\t */\n\theight: number;\n}\n\nexport interface HandleDisplayOptions {\n\t\n\t/**\n\t * Left offset of the handle in %\n\t */\n\tleft: number | null;\n\t\n\t/**\n\t * Top offset of the handle in %\n\t */\n\ttop: number | null;\n}\n\nexport interface SliderHandle {\n\t\n\t/**\n\t * Value of the handle\n\t */\n\tvalue: number;\n\t\n\t/**\n\t * Handle id\n\t */\n\tid: number;\n\t\n\t/**\n\t * ariaLabel of the handle\n\t */\n\tariaLabel: string;\n\t\n\t/**\n\t * ariaValueText of the handle\n\t */\n\tariaValueText: string;\n}\n\nexport interface SliderApi {\n}\n\nexport interface SliderDirectives {\n\t\n\t/**\n\t * Directive to get the slider component elementRef\n\t */\n\tsliderDirective: Directive;\n\t\n\n\t/**\n\t * Directive used to style the progress display for each handle\n\t */\n\tprogressDisplayDirective: Directive<{option: ProgressDisplayOptions}>;\n\t\n\n\t/**\n\t * Directive to apply to the slider clickable area, to directly move the handle to a given specific position\n\t */\n\tclickableAreaDirective: Directive;\n\t\n\n\t/**\n\t * Directive to apply to the slider handle if any\n\t */\n\thandleDirective: Directive<{item: SliderHandle}>;\n\t\n\n\t/**\n\t * Directive to get the minLabel elementRef\n\t */\n\tminLabelDirective: Directive;\n\t\n\n\t/**\n\t * Directive to get the maxLabel elementRef\n\t */\n\tmaxLabelDirective: Directive;\n\t\n\n\t/**\n\t * Directive to apply to the handle when combined label display is active\n\t */\n\tcombinedHandleLabelDisplayDirective: Directive;\n\t\n\n\t/**\n\t * Directive to apply to the handle when combined label display is not active\n\t */\n\thandleLabelDisplayDirective: Directive<{index: number}>;\n}\n\nexport interface SliderActions {\n\t\n\t/**\n\t * Method to handle click on the slider\n\t * @param event - mouse event\n\t */\n\tclick(event: MouseEvent): void;\n\t\n\t/**\n\t * Method to process the keyboard event\n\t * @param event - keyboard event object\n\t * @param handleNumber - id of the modified handle\n\t */\n\tkeydown(event: KeyboardEvent, handleNumber: number): void;\n\t\n\n\t/**\n\t * Method describing the behavior of the slider handle on mouse down event\n\t * @param event - mouse event\n\t * @param handleId - numeric id of the handle\n\t */\n\tmouseDown(event: MouseEvent, handleId: number): void;\n\t\n\n\t/**\n\t * Method describing the behavior of the slider handle on touch start event\n\t * @param event - touch event\n\t * @param handleId - number id of the handle\n\t */\n\ttouchStart(event: TouchEvent, handleId: number): void;\n}\n\n"]}

package/esm2022/components/toast/index.mjs

@@ -1,3 +1,3 @@
 export * from './toast.component';
-export * from './toast';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy90b2FzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90b2FzdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90b2FzdCc7XG4iXX0=
+export * from './toast.gen';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy90b2FzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90b2FzdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90b2FzdC5nZW4nO1xuIl19

package/esm2022/components/toast/toast.component.mjs

@@ -2,7 +2,7 @@ import { BaseWidgetDirective, ComponentTemplate, ContentAsSlotDirective, SlotDir
 import { writable } from '@amadeus-it-group/tansu';
 import { ChangeDetectionStrategy, Component, ContentChild, Directive, EventEmitter, Input, Output, TemplateRef, ViewChild, inject, } from '@angular/core';
 import { callWidgetFactory } from '../../config';
-import { createToast } from './toast';
+import { createToast } from './toast.gen';
 import * as i0 from "@angular/core";
 const _c0 = ["structure"];
 const _c1 = (a0, a1) => ({ state: a0, widget: a1 });
@@ -156,14 +156,29 @@ export class ToastComponent extends BaseWidgetDirective {
         super(...arguments);
         /**
          * Callback called when the alert visibility changed.
+         *
+         * @defaultValue
+         * ```ts
+         * () => {}
+         * ```
          */
         this.visibleChange = new EventEmitter();
         /**
          * Callback called when the alert is hidden.
+         *
+         * @defaultValue
+         * ```ts
+         * () => {}
+         * ```
          */
         this.hidden = new EventEmitter();
         /**
          * Callback called when the alert is shown.
+         *
+         * @defaultValue
+         * ```ts
+         * () => {}
+         * ```
          */
         this.shown = new EventEmitter();
         this.defaultSlots = writable(defaultConfig);
@@ -281,4 +296,4 @@ export class ToastComponent extends BaseWidgetDirective {
             args: ['auClassName']
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ToastComponent, { className: "ToastComponent", filePath: "components/toast/toast.component.ts", lineNumber: 105 }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toast.component.js","sourceRoot":"","sources":["../../../../src/components/toast/toast.component.ts"],"names":[],"mappings":"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","sourcesContent":["import type {SlotContent, TransitionFn} from '@agnos-ui/angular-headless';\nimport {\n\tBaseWidgetDirective,\n\tComponentTemplate,\n\tContentAsSlotDirective,\n\tSlotDirective,\n\tUseDirective,\n\tUseMultiDirective,\n\tauBooleanAttribute,\n\tauNumberAttribute,\n} from '@agnos-ui/angular-headless';\nimport type {WritableSignal} from '@amadeus-it-group/tansu';\nimport {writable} from '@amadeus-it-group/tansu';\nimport type {AfterContentChecked} from '@angular/core';\nimport {\n\tChangeDetectionStrategy,\n\tComponent,\n\tContentChild,\n\tDirective,\n\tEventEmitter,\n\tInput,\n\tOutput,\n\tTemplateRef,\n\tViewChild,\n\tinject,\n} from '@angular/core';\nimport {callWidgetFactory} from '../../config';\n\nimport type {ToastContext, ToastProps, ToastWidget} from './toast';\nimport {createToast} from './toast';\n\n@Directive({selector: 'ng-template[auToastBody]', standalone: true})\nexport class ToastBodyDirective {\n\tpublic templateRef = inject(TemplateRef<ToastContext>);\n\tstatic ngTemplateContextGuard(dir: ToastBodyDirective, context: unknown): context is ToastContext {\n\t\treturn true;\n\t}\n}\n\n@Directive({selector: 'ng-template[auToastStructure]', standalone: true})\nexport class ToastStructureDirective {\n\tpublic templateRef = inject(TemplateRef<ToastContext>);\n\tstatic ngTemplateContextGuard(dir: ToastStructureDirective, context: unknown): context is ToastContext {\n\t\treturn true;\n\t}\n}\n\n@Directive({selector: 'ng-template[auToastHeader]', standalone: true})\nexport class ToastHeaderDirective {\n\tpublic templateRef = inject(TemplateRef<ToastContext>);\n\tstatic ngTemplateContextGuard(dir: ToastHeaderDirective, context: unknown): context is ToastContext {\n\t\treturn true;\n\t}\n}\n@Component({\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [SlotDirective, ToastStructureDirective, UseDirective],\n\ttemplate: ` <ng-template auToastStructure #structure let-state=\"state\" let-widget=\"widget\">\n\t\t@if (state.header) {\n\t\t\t<div class=\"toast-header\">\n\t\t\t\t<ng-template [auSlot]=\"state.header\" [auSlotProps]=\"{state, widget}\"></ng-template>\n\t\t\t\t@if (state.dismissible) {\n\t\t\t\t\t<button class=\"btn-close me-0 ms-auto\" [auUse]=\"widget.directives.closeButtonDirective\"></button>\n\t\t\t\t}\n\t\t\t</div>\n\t\t}\n\t\t<div class=\"toast-body\">\n\t\t\t<ng-template [auSlot]=\"state.children\" [auSlotProps]=\"{state, widget}\"></ng-template>\n\t\t</div>\n\t\t@if (state.dismissible && !state.header) {\n\t\t\t<button class=\"btn-close btn-close-white me-2 m-auto\" [auUse]=\"widget.directives.closeButtonDirective\"></button>\n\t\t}\n\t</ng-template>`,\n})\nexport class ToastDefaultSlotsComponent {\n\t@ViewChild('structure', {static: true}) structure!: TemplateRef<ToastContext>;\n}\n\nexport const toastDefaultSlotStructure = new ComponentTemplate(ToastDefaultSlotsComponent, 'structure');\n\nconst defaultConfig: Partial<ToastProps> = {\n\tstructure: toastDefaultSlotStructure,\n};\n\n@Component({\n\tselector: '[auToast]',\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [SlotDirective, UseMultiDirective, ContentAsSlotDirective],\n\ttemplate: ` <ng-template [auContentAsSlot]=\"defaultSlots\">\n\t\t\t<ng-content></ng-content>\n\t\t</ng-template>\n\t\t@if (!state().hidden) {\n\t\t\t<div\n\t\t\t\tclass=\"toast\"\n\t\t\t\t[class.d-flex]=\"!state().header\"\n\t\t\t\t[class.toast-dismissible]=\"state().dismissible\"\n\t\t\t\t[auUseMulti]=\"[widget.directives.autoHideDirective, widget.directives.transitionDirective, widget.directives.bodyDirective]\"\n\t\t\t>\n\t\t\t\t<ng-template [auSlot]=\"state().structure\" [auSlotProps]=\"{state: state(), widget}\"></ng-template>\n\t\t\t</div>\n\t\t}`,\n})\nexport class ToastComponent extends BaseWidgetDirective<ToastWidget> implements AfterContentChecked {\n\t/**\n\t * If `true`, alert can be dismissed by the user.\n\t * The close button (×) will be displayed and you can be notified of the event with the (close) output.\n\t */\n\t@Input({alias: 'auDismissible', transform: auBooleanAttribute})\n\tdismissible: boolean | undefined;\n\n\t/**\n\t * The transition function will be executed when the alert is displayed or hidden.\n\t * Depending on the value of `animatedOnInit`, the animation can be optionally skipped during the showing process.\n\t */\n\t@Input('auTransition')\n\ttransition: TransitionFn | undefined;\n\n\t/**\n\t * If `true` the alert is visible to the user\n\t */\n\t@Input({alias: 'auVisible', transform: auBooleanAttribute})\n\tvisible: boolean | undefined;\n\n\t/**\n\t * If `true`, alert opening will be animated.\n\t *\n\t * Animation is triggered  when the `.open()` function is called\n\t * or the visible prop is changed\n\t */\n\t@Input({alias: 'auAnimatedOnInit', transform: auBooleanAttribute})\n\tanimatedOnInit: boolean | undefined;\n\n\t/**\n\t * If `true`, alert closing will be animated.\n\t *\n\t * Animation is triggered  when clicked on the close button (×),\n\t * via the `.close()` function or the visible prop is changed\n\t */\n\t@Input({alias: 'auAnimated', transform: auBooleanAttribute})\n\tanimated: boolean | undefined;\n\n\t/**\n\t * If `true` automatically hides the toast after the delay.\n\t */\n\t@Input({alias: 'auAutoHide', transform: auBooleanAttribute})\n\tautoHide: boolean | undefined;\n\n\t/**\n\t * Delay in milliseconds before hiding the toast.\n\t */\n\t@Input({alias: 'auDelay', transform: auNumberAttribute})\n\tdelay: number | undefined;\n\n\t/**\n\t * Accessibility close button label\n\t */\n\t@Input('auAriaCloseButtonLabel') ariaCloseButtonLabel: string | undefined;\n\n\t/**\n\t * Template for the toast content\n\t */\n\t@Input('auChildren') children: SlotContent<ToastContext>;\n\t@ContentChild(ToastBodyDirective, {static: false})\n\tslotDefaultFromContent: ToastBodyDirective | undefined;\n\n\t/**\n\t * Global template for the toast component\n\t */\n\t@Input('auStructure') structure: SlotContent<ToastContext>;\n\t@ContentChild(ToastStructureDirective, {static: false}) slotStructureFromContent: ToastStructureDirective | undefined;\n\n\t/**\n\t * Header template for the toast component\n\t */\n\t@Input('auHeader') header: SlotContent<ToastContext>;\n\t@ContentChild(ToastHeaderDirective, {static: false}) slotHeaderFromContent: ToastHeaderDirective | undefined;\n\n\t/**\n\t * Callback called when the alert visibility changed.\n\t */\n\t@Output('auVisibleChange') visibleChange = new EventEmitter<boolean>();\n\n\t/**\n\t * Callback called when the alert is hidden.\n\t */\n\t@Output('auHidden') hidden = new EventEmitter<void>();\n\n\t/**\n\t * Callback called when the alert is shown.\n\t */\n\t@Output('auShown') shown = new EventEmitter<void>();\n\n\treadonly defaultSlots: WritableSignal<Partial<ToastProps>> = writable(defaultConfig);\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t */\n\t@Input('auClassName') className: string | undefined;\n\n\treadonly _widget = callWidgetFactory({\n\t\tfactory: createToast,\n\t\twidgetName: 'toast',\n\t\tdefaultConfig: this.defaultSlots,\n\t\tevents: {\n\t\t\tonVisibleChange: (event) => this.visibleChange.emit(event),\n\t\t\tonShown: () => this.shown.emit(),\n\t\t\tonHidden: () => this.hidden.emit(),\n\t\t},\n\t});\n\n\tngAfterContentChecked(): void {\n\t\tthis._widget.patchSlots({\n\t\t\tchildren: this.slotDefaultFromContent?.templateRef,\n\t\t\tstructure: this.slotStructureFromContent?.templateRef,\n\t\t\theader: this.slotHeaderFromContent?.templateRef,\n\t\t});\n\t}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toast.component.js","sourceRoot":"","sources":["../../../../src/components/toast/toast.component.ts"],"names":[],"mappings":"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","sourcesContent":["import type {SlotContent, TransitionFn} from '@agnos-ui/angular-headless';\nimport {\n\tBaseWidgetDirective,\n\tComponentTemplate,\n\tContentAsSlotDirective,\n\tSlotDirective,\n\tUseDirective,\n\tUseMultiDirective,\n\tauBooleanAttribute,\n\tauNumberAttribute,\n} from '@agnos-ui/angular-headless';\nimport type {WritableSignal} from '@amadeus-it-group/tansu';\nimport {writable} from '@amadeus-it-group/tansu';\nimport type {AfterContentChecked} from '@angular/core';\nimport {\n\tChangeDetectionStrategy,\n\tComponent,\n\tContentChild,\n\tDirective,\n\tEventEmitter,\n\tInput,\n\tOutput,\n\tTemplateRef,\n\tViewChild,\n\tinject,\n} from '@angular/core';\nimport {callWidgetFactory} from '../../config';\n\nimport type {ToastContext, ToastProps, ToastWidget} from './toast.gen';\nimport {createToast} from './toast.gen';\n\n@Directive({selector: 'ng-template[auToastBody]', standalone: true})\nexport class ToastBodyDirective {\n\tpublic templateRef = inject(TemplateRef<ToastContext>);\n\tstatic ngTemplateContextGuard(dir: ToastBodyDirective, context: unknown): context is ToastContext {\n\t\treturn true;\n\t}\n}\n\n@Directive({selector: 'ng-template[auToastStructure]', standalone: true})\nexport class ToastStructureDirective {\n\tpublic templateRef = inject(TemplateRef<ToastContext>);\n\tstatic ngTemplateContextGuard(dir: ToastStructureDirective, context: unknown): context is ToastContext {\n\t\treturn true;\n\t}\n}\n\n@Directive({selector: 'ng-template[auToastHeader]', standalone: true})\nexport class ToastHeaderDirective {\n\tpublic templateRef = inject(TemplateRef<ToastContext>);\n\tstatic ngTemplateContextGuard(dir: ToastHeaderDirective, context: unknown): context is ToastContext {\n\t\treturn true;\n\t}\n}\n@Component({\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [SlotDirective, ToastStructureDirective, UseDirective],\n\ttemplate: ` <ng-template auToastStructure #structure let-state=\"state\" let-widget=\"widget\">\n\t\t@if (state.header) {\n\t\t\t<div class=\"toast-header\">\n\t\t\t\t<ng-template [auSlot]=\"state.header\" [auSlotProps]=\"{state, widget}\"></ng-template>\n\t\t\t\t@if (state.dismissible) {\n\t\t\t\t\t<button class=\"btn-close me-0 ms-auto\" [auUse]=\"widget.directives.closeButtonDirective\"></button>\n\t\t\t\t}\n\t\t\t</div>\n\t\t}\n\t\t<div class=\"toast-body\">\n\t\t\t<ng-template [auSlot]=\"state.children\" [auSlotProps]=\"{state, widget}\"></ng-template>\n\t\t</div>\n\t\t@if (state.dismissible && !state.header) {\n\t\t\t<button class=\"btn-close btn-close-white me-2 m-auto\" [auUse]=\"widget.directives.closeButtonDirective\"></button>\n\t\t}\n\t</ng-template>`,\n})\nexport class ToastDefaultSlotsComponent {\n\t@ViewChild('structure', {static: true}) structure!: TemplateRef<ToastContext>;\n}\n\nexport const toastDefaultSlotStructure = new ComponentTemplate(ToastDefaultSlotsComponent, 'structure');\n\nconst defaultConfig: Partial<ToastProps> = {\n\tstructure: toastDefaultSlotStructure,\n};\n\n@Component({\n\tselector: '[auToast]',\n\tstandalone: true,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [SlotDirective, UseMultiDirective, ContentAsSlotDirective],\n\ttemplate: ` <ng-template [auContentAsSlot]=\"defaultSlots\">\n\t\t\t<ng-content></ng-content>\n\t\t</ng-template>\n\t\t@if (!state().hidden) {\n\t\t\t<div\n\t\t\t\tclass=\"toast\"\n\t\t\t\t[class.d-flex]=\"!state().header\"\n\t\t\t\t[class.toast-dismissible]=\"state().dismissible\"\n\t\t\t\t[auUseMulti]=\"[widget.directives.autoHideDirective, widget.directives.transitionDirective, widget.directives.bodyDirective]\"\n\t\t\t>\n\t\t\t\t<ng-template [auSlot]=\"state().structure\" [auSlotProps]=\"{state: state(), widget}\"></ng-template>\n\t\t\t</div>\n\t\t}`,\n})\nexport class ToastComponent extends BaseWidgetDirective<ToastWidget> implements AfterContentChecked {\n\t/**\n\t * If `true`, alert can be dismissed by the user.\n\t * The close button (×) will be displayed and you can be notified of the event with the (close) output.\n\t *\n\t * @defaultValue `true`\n\t */\n\t@Input({alias: 'auDismissible', transform: auBooleanAttribute})\n\tdismissible: boolean | undefined;\n\n\t/**\n\t * The transition function will be executed when the alert is displayed or hidden.\n\t *\n\t * Depending on the value of `animatedOnInit`, the animation can be optionally skipped during the showing process.\n\t *\n\t * @defaultValue `fadeTransition`\n\t */\n\t@Input('auTransition')\n\ttransition: TransitionFn | undefined;\n\n\t/**\n\t * If `true` the alert is visible to the user\n\t *\n\t * @defaultValue `true`\n\t */\n\t@Input({alias: 'auVisible', transform: auBooleanAttribute})\n\tvisible: boolean | undefined;\n\n\t/**\n\t * If `true`, alert opening will be animated.\n\t *\n\t * Animation is triggered  when the `.open()` function is called\n\t * or the visible prop is changed\n\t *\n\t * @defaultValue `false`\n\t */\n\t@Input({alias: 'auAnimatedOnInit', transform: auBooleanAttribute})\n\tanimatedOnInit: boolean | undefined;\n\n\t/**\n\t * If `true`, alert closing will be animated.\n\t *\n\t * Animation is triggered  when clicked on the close button (×),\n\t * via the `.close()` function or the visible prop is changed\n\t *\n\t * @defaultValue `true`\n\t */\n\t@Input({alias: 'auAnimated', transform: auBooleanAttribute})\n\tanimated: boolean | undefined;\n\n\t/**\n\t * If `true` automatically hides the toast after the delay.\n\t *\n\t * @defaultValue `true`\n\t */\n\t@Input({alias: 'auAutoHide', transform: auBooleanAttribute})\n\tautoHide: boolean | undefined;\n\n\t/**\n\t * Delay in milliseconds before hiding the toast.\n\t *\n\t * @defaultValue `5000`\n\t */\n\t@Input({alias: 'auDelay', transform: auNumberAttribute})\n\tdelay: number | undefined;\n\n\t/**\n\t * Accessibility close button label\n\t *\n\t * @defaultValue `'Close'`\n\t */\n\t@Input('auAriaCloseButtonLabel') ariaCloseButtonLabel: string | undefined;\n\n\t/**\n\t * Template for the toast content\n\t */\n\t@Input('auChildren') children: SlotContent<ToastContext>;\n\t@ContentChild(ToastBodyDirective, {static: false})\n\tslotDefaultFromContent: ToastBodyDirective | undefined;\n\n\t/**\n\t * Global template for the toast component\n\t */\n\t@Input('auStructure') structure: SlotContent<ToastContext>;\n\t@ContentChild(ToastStructureDirective, {static: false}) slotStructureFromContent: ToastStructureDirective | undefined;\n\n\t/**\n\t * Header template for the toast component\n\t */\n\t@Input('auHeader') header: SlotContent<ToastContext>;\n\t@ContentChild(ToastHeaderDirective, {static: false}) slotHeaderFromContent: ToastHeaderDirective | undefined;\n\n\t/**\n\t * Callback called when the alert visibility changed.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\t@Output('auVisibleChange') visibleChange = new EventEmitter<boolean>();\n\n\t/**\n\t * Callback called when the alert is hidden.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\t@Output('auHidden') hidden = new EventEmitter<void>();\n\n\t/**\n\t * Callback called when the alert is shown.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\t@Output('auShown') shown = new EventEmitter<void>();\n\n\treadonly defaultSlots: WritableSignal<Partial<ToastProps>> = writable(defaultConfig);\n\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t *\n\t * @defaultValue `''`\n\t */\n\t@Input('auClassName') className: string | undefined;\n\n\treadonly _widget = callWidgetFactory({\n\t\tfactory: createToast,\n\t\twidgetName: 'toast',\n\t\tdefaultConfig: this.defaultSlots,\n\t\tevents: {\n\t\t\tonVisibleChange: (event) => this.visibleChange.emit(event),\n\t\t\tonShown: () => this.shown.emit(),\n\t\t\tonHidden: () => this.hidden.emit(),\n\t\t},\n\t});\n\n\tngAfterContentChecked(): void {\n\t\tthis._widget.patchSlots({\n\t\t\tchildren: this.slotDefaultFromContent?.templateRef,\n\t\t\tstructure: this.slotStructureFromContent?.templateRef,\n\t\t\theader: this.slotHeaderFromContent?.templateRef,\n\t\t});\n\t}\n}\n"]}

package/esm2022/components/toast/toast.gen.mjs

@@ -1,2 +1,15 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,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
+import { getToastDefaultConfig, createToast } from '@agnos-ui/core-bootstrap/components/toast';
+/**
+ * Retrieve a shallow copy of the default Toast config
+ * @returns the default Toast config
+ */
+const export_getToastDefaultConfig = getToastDefaultConfig;
+export { export_getToastDefaultConfig as getToastDefaultConfig };
+/**
+ * Create an ToastWidget with given config props
+ * @param config - an optional alert config
+ * @returns an ToastWidget
+ */
+const export_createToast = createToast;
+export { export_createToast as createToast };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toast.gen.js","sourceRoot":"","sources":["../../../../src/components/toast/toast.gen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,qBAAqB,EAAE,WAAW,EAAC,MAAM,2CAA2C,CAAC;AAK7F;;;GAGG;AACH,MAAM,4BAA4B,GAAqB,qBAA4B,CAAC;AACpF,OAAO,EAAC,4BAA4B,IAAI,qBAAqB,EAAC,CAAC;AA2M/D;;;;GAIG;AACH,MAAM,kBAAkB,GAA+B,WAAkB,CAAC;AAC1E,OAAO,EAAC,kBAAkB,IAAI,WAAW,EAAC,CAAC","sourcesContent":["import {getToastDefaultConfig, createToast} from '@agnos-ui/core-bootstrap/components/toast';\nimport type {WidgetSlotContext, SlotContent, TransitionFn, Widget, WidgetFactory, Directive} from '@agnos-ui/angular-headless';\n\n\n\n/**\n * Retrieve a shallow copy of the default Toast config\n * @returns the default Toast config\n */\nconst export_getToastDefaultConfig: () => ToastProps = getToastDefaultConfig as any;\nexport {export_getToastDefaultConfig as getToastDefaultConfig};\n\n\n\nexport type ToastContext = WidgetSlotContext<ToastWidget>;\n\nexport interface ToastState {\n\t\n\t/**\n\t * Is `true` when the alert is hidden. Compared to `visible`, this is updated after the transition is executed.\n\t */\n\thidden: boolean;\n\t\n\t/**\n\t * If `true`, alert can be dismissed by the user.\n\t * The close button (×) will be displayed and you can be notified of the event with the (close) output.\n\t *\n\t * @defaultValue `true`\n\t */\n\tdismissible: boolean;\n\t\n\t/**\n\t * If `true` the alert is visible to the user\n\t *\n\t * @defaultValue `true`\n\t */\n\tvisible: boolean;\n\t\n\n\t/**\n\t * Accessibility close button label\n\t *\n\t * @defaultValue `'Close'`\n\t */\n\tariaCloseButtonLabel: string;\n\t\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t *\n\t * @defaultValue `''`\n\t */\n\tclassName: string;\n\t\n\t/**\n\t * If `true` automatically hides the toast after the delay.\n\t *\n\t * @defaultValue `true`\n\t */\n\tautoHide: boolean;\n\t\n\t/**\n\t * Delay in milliseconds before hiding the toast.\n\t *\n\t * @defaultValue `5000`\n\t */\n\tdelay: number;\n\t\n\t/**\n\t * Global template for the toast component\n\t */\n\tstructure: SlotContent<ToastContext>;\n\t\n\t/**\n\t * Template for the toast content\n\t */\n\tchildren: SlotContent<ToastContext>;\n\t\n\t/**\n\t * Header template for the toast component\n\t */\n\theader: SlotContent<ToastContext>;\n}\n\nexport interface ToastProps {\n\t\n\t/**\n\t * The transition function will be executed when the alert is displayed or hidden.\n\t *\n\t * Depending on the value of `animatedOnInit`, the animation can be optionally skipped during the showing process.\n\t *\n\t * @defaultValue `fadeTransition`\n\t */\n\ttransition: TransitionFn;\n\t\n\t/**\n\t * Callback called when the alert visibility changed.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\tonVisibleChange: (visible: boolean) => void;\n\t\n\n\t/**\n\t * Callback called when the alert is hidden.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\tonHidden: () => void;\n\t\n\n\t/**\n\t * Callback called when the alert is shown.\n\t *\n\t * @defaultValue\n\t * ```ts\n\t * () => {}\n\t * ```\n\t */\n\tonShown: () => void;\n\t\n\n\t/**\n\t * If `true`, alert opening will be animated.\n\t *\n\t * Animation is triggered  when the `.open()` function is called\n\t * or the visible prop is changed\n\t *\n\t * @defaultValue `false`\n\t */\n\tanimatedOnInit: boolean;\n\t\n\t/**\n\t * If `true`, alert closing will be animated.\n\t *\n\t * Animation is triggered  when clicked on the close button (×),\n\t * via the `.close()` function or the visible prop is changed\n\t *\n\t * @defaultValue `true`\n\t */\n\tanimated: boolean;\n\t\n\t/**\n\t * If `true`, alert can be dismissed by the user.\n\t * The close button (×) will be displayed and you can be notified of the event with the (close) output.\n\t *\n\t * @defaultValue `true`\n\t */\n\tdismissible: boolean;\n\t\n\t/**\n\t * If `true` the alert is visible to the user\n\t *\n\t * @defaultValue `true`\n\t */\n\tvisible: boolean;\n\t\n\n\t/**\n\t * Accessibility close button label\n\t *\n\t * @defaultValue `'Close'`\n\t */\n\tariaCloseButtonLabel: string;\n\t\n\t/**\n\t * CSS classes to be applied on the widget main container\n\t *\n\t * @defaultValue `''`\n\t */\n\tclassName: string;\n\t\n\t/**\n\t * If `true` automatically hides the toast after the delay.\n\t *\n\t * @defaultValue `true`\n\t */\n\tautoHide: boolean;\n\t\n\t/**\n\t * Delay in milliseconds before hiding the toast.\n\t *\n\t * @defaultValue `5000`\n\t */\n\tdelay: number;\n\t\n\t/**\n\t * Global template for the toast component\n\t */\n\tstructure: SlotContent<ToastContext>;\n\t\n\t/**\n\t * Template for the toast content\n\t */\n\tchildren: SlotContent<ToastContext>;\n\t\n\t/**\n\t * Header template for the toast component\n\t */\n\theader: SlotContent<ToastContext>;\n}\n\n\n\nexport type ToastWidget = Widget<ToastProps, ToastState, ToastApi, object, ToastDirectives>;\n\n\n\n/**\n * Create an ToastWidget with given config props\n * @param config - an optional alert config\n * @returns an ToastWidget\n */\nconst export_createToast: WidgetFactory<ToastWidget> = createToast as any;\nexport {export_createToast as createToast};\n\nexport interface ToastApi {\n\t\n\t/**\n\t * Triggers alert closing programmatically (same as clicking on the close button (×)).\n\t */\n\tclose(): void;\n\t\n\n\t/**\n\t * Triggers the alert to be displayed for the user.\n\t */\n\topen(): void;\n}\n\nexport interface ToastDirectives {\n\t\n\t/**\n\t * the transition directive, piloting what is the visual effect of going from hidden to visible\n\t */\n\ttransitionDirective: Directive;\n\t\n\t/**\n\t * Directive that handles the autohide of the toast component\n\t */\n\tautoHideDirective: Directive;\n\t\n\t/**\n\t * Directive that adds all the necessary attributes to the body\n\t */\n\tbodyDirective: Directive;\n\t\n\t/**\n\t * Directive that adds all the necessary attributes to the close button depending on the presence of the header\n\t */\n\tcloseButtonDirective: Directive;\n}\n\n"]}