@agnos-ui/core 0.2.0 → 0.3.1

package/writables-DoU_XYTX.js

@@ -0,0 +1,86 @@
+import { INVALID_VALUE } from "./types.js";
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value) && Number.isFinite(value);
+}
+function isBoolean(value) {
+  return value === true || value === false;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+const isArray = Array.isArray;
+function clamp(value, max, min = 0) {
+  return Math.max(Math.min(value, max), min);
+}
+const isHTMLElement = (value) => value instanceof HTMLElement;
+const allowNull = (isType) => (value) => value === null || isType(value);
+const testToNormalizeValue = (filter) => (value) => filter(value) ? value : INVALID_VALUE;
+const numberNormalizeFn = testToNormalizeValue(isNumber);
+const typeNumber = {
+  normalizeValue: numberNormalizeFn
+};
+function typeNumberInRangeFactory(min, max, options = {}) {
+  const { strict = false, useClamp = true } = options;
+  return {
+    normalizeValue: (value) => {
+      let normalizedNumber = numberNormalizeFn(value);
+      if (normalizedNumber !== INVALID_VALUE) {
+        if (!strict && useClamp) {
+          normalizedNumber = clamp(normalizedNumber, max, min);
+        }
+        if (normalizedNumber >= min && normalizedNumber <= max) {
+          if (!strict || normalizedNumber !== min && normalizedNumber !== max) {
+            return normalizedNumber;
+          }
+        }
+      }
+      return INVALID_VALUE;
+    }
+  };
+}
+const typeBoolean = {
+  normalizeValue: testToNormalizeValue(isBoolean)
+};
+const typeBooleanOrNull = {
+  normalizeValue: testToNormalizeValue(allowNull(isBoolean))
+};
+const typeString = {
+  normalizeValue: testToNormalizeValue(isString)
+};
+const typeFunction = {
+  normalizeValue: testToNormalizeValue(isFunction),
+  equal: Object.is
+};
+const typeHTMLElementOrNull = {
+  normalizeValue: testToNormalizeValue(allowNull(isHTMLElement)),
+  equal: Object.is
+};
+const typeArray = {
+  normalizeValue: testToNormalizeValue(isArray),
+  equal: (a, b) => {
+    if (a === b) {
+      return true;
+    } else {
+      if ((a == null ? void 0 : a.length) !== (b == null ? void 0 : b.length)) {
+        return false;
+      }
+      return a.every((val, index) => val === b[index]);
+    }
+  }
+};
+export {
+  typeNumber as a,
+  typeNumberInRangeFactory as b,
+  typeBoolean as c,
+  typeBooleanOrNull as d,
+  typeString as e,
+  typeFunction as f,
+  typeHTMLElementOrNull as g,
+  typeArray as h,
+  clamp as i,
+  isNumber as j,
+  testToNormalizeValue as t
+};

package/components/accordion/accordion.js

@@ -1,264 +0,0 @@
-import { stateStores, writablesForProps, normalizeConfigStores, mergeConfigStores } from '../../utils/stores';
-import { createTransition } from '../../services/transitions/baseTransitions';
-import { collapseVerticalTransition } from '../../services/transitions/bootstrap/collapse';
-import { computed, writable } from '@amadeus-it-group/tansu';
-import { noop } from '../../utils/internal/func';
-import { typeBoolean, typeFunction, typeString } from '../../utils/writables';
-import { bindDirectiveNoArg, directiveSubscribe, registrationArray } from '../../utils/directive';
-import { generateId } from '../../utils/internal/dom';
-function adjustItemsCloseOthers(items, openItems, oldOpen) {
-    let keepOpen;
-    if (openItems.length == 2) {
-        oldOpen = oldOpen ?? openItems[0];
-        keepOpen = openItems.find((id) => id !== oldOpen);
-    }
-    else if (openItems.length > 2) {
-        //this case can happen when you have multiple items open and you toggle the close others
-        keepOpen = openItems[0];
-    }
-    if (keepOpen) {
-        items.forEach((item) => {
-            if (item.state$().itemId !== keepOpen && item.state$().itemVisible) {
-                item.patch({ itemVisible: false });
-            }
-        });
-    }
-    return items;
-}
-function getItem(items, itemId) {
-    return items.find((item) => item.state$().itemId === itemId);
-}
-const defaultAccordionConfig = {
-    closeOthers: false,
-    onShown: noop,
-    onHidden: noop,
-    className: '',
-    itemId: '',
-    itemDestroyOnHide: true,
-    itemDisabled: false,
-    itemVisible: false,
-    itemAnimation: true,
-    itemTransition: collapseVerticalTransition,
-    itemHeadingTag: '',
-    onItemShown: noop,
-    onItemHidden: noop,
-    onItemVisibleChange: noop,
-    slotItemStructure: undefined,
-    slotItemBody: undefined,
-    slotItemHeader: undefined,
-    itemClass: '',
-    itemHeaderClass: '',
-    itemButtonClass: '',
-    itemBodyContainerClass: '',
-    itemBodyClass: '',
-};
-const defaultItemConfig = {
-    itemId: defaultAccordionConfig.itemId,
-    itemDestroyOnHide: defaultAccordionConfig.itemDestroyOnHide,
-    itemDisabled: defaultAccordionConfig.itemDisabled,
-    itemVisible: defaultAccordionConfig.itemVisible,
-    itemAnimation: defaultAccordionConfig.itemAnimation,
-    itemTransition: defaultAccordionConfig.itemTransition,
-    onItemShown: defaultAccordionConfig.onItemShown,
-    onItemHidden: defaultAccordionConfig.onItemHidden,
-    onItemVisibleChange: defaultAccordionConfig.onItemVisibleChange,
-    slotItemStructure: defaultAccordionConfig.slotItemStructure,
-    slotItemBody: defaultAccordionConfig.slotItemBody,
-    slotItemHeader: defaultAccordionConfig.slotItemHeader,
-    itemClass: defaultAccordionConfig.itemClass,
-    itemHeaderClass: defaultAccordionConfig.itemHeaderClass,
-    itemButtonClass: defaultAccordionConfig.itemButtonClass,
-    itemBodyContainerClass: defaultAccordionConfig.itemBodyContainerClass,
-    itemBodyClass: defaultAccordionConfig.itemBodyClass,
-    itemHeadingTag: defaultAccordionConfig.itemHeadingTag,
-};
-const accordionItemProps = Object.keys(defaultItemConfig);
-/**
- * Retrieve a shallow copy of the default accordion config
- * @returns the default accordion config
- */
-export function getAccordionDefaultConfig() {
-    return { ...defaultAccordionConfig };
-}
-const configAccordionValidator = {
-    closeOthers: typeBoolean,
-    onShown: typeFunction,
-    onHidden: typeFunction,
-    itemId: typeString,
-    itemDestroyOnHide: typeBoolean,
-    itemDisabled: typeBoolean,
-    itemVisible: typeBoolean,
-    itemAnimation: typeBoolean,
-    itemTransition: typeFunction,
-    onItemShown: typeFunction,
-    onItemHidden: typeFunction,
-    onItemVisibleChange: typeFunction,
-    itemClass: typeString,
-    itemHeaderClass: typeString,
-    itemButtonClass: typeString,
-    itemBodyContainerClass: typeString,
-    itemBodyClass: typeString,
-    itemHeadingTag: typeString,
-};
-const configItemValidator = {
-    itemId: typeString,
-    itemDestroyOnHide: typeBoolean,
-    itemDisabled: typeBoolean,
-    itemVisible: typeBoolean,
-    itemAnimation: typeBoolean,
-    itemTransition: typeFunction,
-    onItemShown: typeFunction,
-    onItemHidden: typeFunction,
-    onItemVisibleChange: typeFunction,
-    itemClass: typeString,
-    itemHeaderClass: typeString,
-    itemButtonClass: typeString,
-    itemBodyContainerClass: typeString,
-    itemBodyClass: typeString,
-    itemHeadingTag: typeString,
-};
-function createAccordionItem(accordionOnShown, accordionOnHidden, config) {
-    const [{ itemAnimation$, itemTransition$, itemDestroyOnHide$, onItemShown$, onItemHidden$, onItemVisibleChange$, itemVisible$, itemId$: _dirtyItemId$, itemDisabled$, ...stateProps }, patch,] = writablesForProps(defaultItemConfig, config, configItemValidator);
-    const initDone$ = writable(false);
-    const _autoItemId$ = computed(() => generateId());
-    const itemId$ = computed(() => _dirtyItemId$() || _autoItemId$());
-    const shouldBeInDOM$ = computed(() => itemDestroyOnHide$() === false || !itemTransition.state$().hidden);
-    const itemTransition = createTransition({
-        props: {
-            transition: itemTransition$,
-            visible: itemVisible$,
-            onVisibleChange: onItemVisibleChange$,
-            animation: itemAnimation$,
-            animationOnInit: false,
-            initDone: initDone$,
-            onHidden: () => {
-                accordionOnHidden()(itemId$());
-                onItemHidden$()();
-            },
-            onShown: () => {
-                accordionOnShown()(itemId$());
-                onItemShown$()();
-            },
-        },
-    });
-    return {
-        ...stateStores({
-            itemVisible$,
-            itemId$,
-            shouldBeInDOM$,
-            itemDisabled$,
-            ...stateProps,
-        }),
-        patch,
-        actions: {
-            click: () => {
-                if (!itemDisabled$()) {
-                    itemVisible$.update((c) => !c);
-                }
-            },
-        },
-        api: {
-            initDone: () => {
-                initDone$.set(true);
-            },
-            collapse: () => {
-                itemVisible$.set(false);
-            },
-            expand: () => {
-                itemVisible$.set(true);
-            },
-            toggle: () => {
-                itemVisible$.update((c) => !c);
-            },
-        },
-        directives: { collapseDirective: bindDirectiveNoArg(itemTransition.directives.directive), accordionItemDirective: noop },
-    };
-}
-/**
- * Creates a new Accordion widget instance.
- * @param config - config of the accordion, either as a store or as an object containing values or stores.
- * @returns a new accordion widget instance
- */
-export function createAccordion(config) {
-    const [{ closeOthers$, onShown$, onHidden$, itemId$, itemAnimation$, itemClass$, itemDisabled$, itemVisible$, itemTransition$, itemDestroyOnHide$, itemBodyClass$, itemButtonClass$, itemBodyContainerClass$, itemHeaderClass$, itemHeadingTag$, onItemVisibleChange$, onItemHidden$, onItemShown$, slotItemStructure$, slotItemBody$, slotItemHeader$, ...stateProps }, patch,] = writablesForProps(defaultAccordionConfig, config, configAccordionValidator);
-    const accordionItemConfig = {
-        itemId: itemId$,
-        itemClass: itemClass$,
-        itemAnimation: itemAnimation$,
-        itemDisabled: itemDisabled$,
-        itemVisible: itemVisible$,
-        itemTransition: itemTransition$,
-        itemDestroyOnHide: itemDestroyOnHide$,
-        itemBodyClass: itemBodyClass$,
-        itemButtonClass: itemButtonClass$,
-        itemBodyContainerClass: itemBodyContainerClass$,
-        itemHeaderClass: itemHeaderClass$,
-        itemHeadingTag: itemHeadingTag$,
-        onItemVisibleChange: onItemVisibleChange$,
-        onItemHidden: onItemHidden$,
-        onItemShown: onItemShown$,
-        slotItemStructure: slotItemStructure$,
-        slotItemBody: slotItemBody$,
-        slotItemHeader: slotItemHeader$,
-    };
-    const itemsWidget$ = registrationArray();
-    const openItems$ = computed(() => {
-        const openItems = [];
-        itemsWidget$().forEach((item) => {
-            if (item.state$().itemVisible) {
-                openItems.push(item.state$().itemId);
-            }
-        });
-        return openItems;
-    });
-    const oldOpenItem$ = writable(openItems$()[0]);
-    const checkCloseOthersAction$ = computed(() => {
-        if (closeOthers$()) {
-            adjustItemsCloseOthers(itemsWidget$(), openItems$(), oldOpenItem$());
-            oldOpenItem$.set(openItems$()[0]);
-        }
-    });
-    const action$ = computed(() => {
-        checkCloseOthersAction$();
-    });
-    return {
-        ...stateStores({ itemsWidget$, ...stateProps }),
-        patch,
-        actions: {},
-        api: {
-            isExpanded: (id) => {
-                const item = getItem(itemsWidget$(), id);
-                if (item) {
-                    return item.state$().itemVisible;
-                }
-                else {
-                    return false;
-                }
-            },
-            expand: (id) => {
-                getItem(itemsWidget$(), id)?.api.expand();
-            },
-            collapse: (id) => {
-                getItem(itemsWidget$(), id)?.api.collapse();
-            },
-            toggle: (id) => {
-                getItem(itemsWidget$(), id)?.api.toggle();
-            },
-            expandAll: () => {
-                itemsWidget$().forEach((i) => i.api.expand());
-            },
-            collapseAll: () => {
-                itemsWidget$().forEach((i) => i.api.collapse());
-            },
-            registerItem: (propsConfig) => {
-                const item = createAccordionItem(onShown$, onHidden$, {
-                    config: mergeConfigStores(accordionItemProps, normalizeConfigStores(accordionItemProps, propsConfig?.config), accordionItemConfig),
-                    props: propsConfig?.props,
-                });
-                item.directives.accordionItemDirective = () => ({ destroy: itemsWidget$.register(item) });
-                return item;
-            },
-        },
-        directives: { accordionDirective: directiveSubscribe(action$) },
-    };
-}

package/components/alert/alert.js

@@ -1,22 +0,0 @@
-import { createCommonAlert, getCommonAlertDefaultConfig } from './common';
-import { extendWidgetProps } from '../../services/extendWidget';
-import { typeString } from '../../utils/writables';
-const alertDefaultConfig = {
-    type: 'primary',
-};
-const alertConfigValidator = {
-    type: typeString,
-};
-/**
- * Retrieve a shallow copy of the default alert config
- * @returns the default alert config
- */
-export function getAlertDefaultConfig() {
-    return { ...getCommonAlertDefaultConfig(), ...alertDefaultConfig };
-}
-/**
- * Create an AlertWidget with given config props
- * @param config - an optional alert config
- * @returns an AlertWidget
- */
-export const createAlert = extendWidgetProps(createCommonAlert, alertDefaultConfig, alertConfigValidator);

package/components/alert/common.js

@@ -1,69 +0,0 @@
-import { createTransition } from '../../services/transitions/baseTransitions';
-import { noop } from '../../utils/internal/func';
-import { fadeTransition } from '../../services/transitions/bootstrap/fade';
-import { stateStores, writablesForProps } from '../../utils/stores';
-import { bindDirectiveNoArg } from '../../utils/directive';
-import { typeBoolean } from '../../utils/writables';
-export const defaultCommonAlertConfig = {
-    visible: true,
-    dismissible: true,
-    ariaCloseButtonLabel: 'Close',
-    onVisibleChange: noop,
-    onShown: noop,
-    onHidden: noop,
-    slotStructure: undefined,
-    slotDefault: undefined,
-    animation: true,
-    animationOnInit: false,
-    transition: fadeTransition,
-    className: '',
-};
-/**
- * Retrieve a shallow copy of the default alert config
- * @returns the default alert config
- */
-export function getCommonAlertDefaultConfig() {
-    return { ...defaultCommonAlertConfig };
-}
-export const commonAlertConfigValidator = {
-    dismissible: typeBoolean,
-};
-/**
- * Create an AlertWidget with given config props
- * @param config - an optional alert config
- * @returns an AlertWidget
- */
-export function createCommonAlert(config) {
-    const [{ transition$, animationOnInit$, animation$, visible$: requestedVisible$, onVisibleChange$, onHidden$, onShown$, ...stateProps }, patch,] = writablesForProps(defaultCommonAlertConfig, config, commonAlertConfigValidator);
-    const transition = createTransition({
-        props: {
-            transition: transition$,
-            visible: requestedVisible$,
-            animation: animation$,
-            animationOnInit: animationOnInit$,
-            onVisibleChange: onVisibleChange$,
-            onHidden: onHidden$,
-            onShown: onShown$,
-        },
-    });
-    const close = () => {
-        patch({ visible: false });
-    };
-    const open = () => {
-        patch({ visible: true });
-    };
-    const visible$ = transition.stores.visible$;
-    const hidden$ = transition.stores.hidden$;
-    return {
-        ...stateStores({ ...stateProps, visible$, hidden$ }),
-        patch,
-        api: {
-            open,
-            close,
-        },
-        directives: {
-            transitionDirective: bindDirectiveNoArg(transition.directives.directive),
-        },
-        actions: {},
-    };
-}

package/components/commonProps.js

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

package/components/modal/modal.js

@@ -1,186 +0,0 @@
-import { computed, readable } from '@amadeus-it-group/tansu';
-import { typeBoolean, typeFunction, typeHTMLElementOrNull, typeString } from '../../utils/writables';
-import { stateStores, writablesForProps } from '../../utils/stores';
-import { createTransition } from '../../services/transitions/baseTransitions';
-import { fadeTransition } from '../../services/transitions/bootstrap/fade';
-import { promiseFromStore } from '../../utils/internal/promise';
-import { noop } from '../../utils/internal/func';
-import { removeScrollbars, revertScrollbars } from '../../utils/internal/scrollbars';
-import { bindDirective, bindDirectiveNoArg, directiveSubscribe, mergeDirectives, registrationArray } from '../../utils/directive';
-import { portal } from '../../services/portal';
-import { sliblingsInert } from '../../services/siblingsInert';
-/**
- * Value present in the {@link ModalBeforeCloseEvent.result|result} property of the {@link ModalProps.onBeforeClose|onBeforeClose} event
- * and returned by the {@link ModalApi.open|open} method, when the modal is closed by a click inside the viewport but outside the modal.
- */
-export const modalOutsideClick = Symbol();
-/**
- * Value present in the {@link ModalBeforeCloseEvent.result|result} property of the {@link ModalProps.onBeforeClose|onBeforeClose} event
- * and returned by the {@link ModalApi.open|open} method, when the modal is closed by a click on the close button.
- */
-export const modalCloseButtonClick = Symbol();
-const defaultConfig = {
-    animation: true,
-    ariaCloseButtonLabel: 'Close',
-    backdrop: true,
-    backdropClass: '',
-    backdropTransition: fadeTransition, // TODO: is it ok to depend on bootstrap transition?
-    closeButton: true,
-    closeOnOutsideClick: true,
-    container: typeof window !== 'undefined' ? document.body : null,
-    className: '',
-    modalTransition: fadeTransition, // TODO: is it ok to depend on bootstrap transition?
-    onBeforeClose: noop,
-    onVisibleChange: noop,
-    onHidden: noop,
-    onShown: noop,
-    slotDefault: undefined,
-    slotFooter: undefined,
-    slotHeader: undefined,
-    slotStructure: undefined,
-    slotTitle: undefined,
-    visible: false,
-    contentData: undefined,
-};
-const configValidator = {
-    animation: typeBoolean,
-    ariaCloseButtonLabel: typeString,
-    backdrop: typeBoolean,
-    backdropClass: typeString,
-    backdropTransition: typeFunction,
-    closeButton: typeBoolean,
-    closeOnOutsideClick: typeBoolean,
-    container: typeHTMLElementOrNull,
-    className: typeString,
-    modalTransition: typeFunction,
-    onBeforeClose: typeFunction,
-    onVisibleChange: typeFunction,
-    onHidden: typeFunction,
-    onShown: typeFunction,
-    visible: typeBoolean,
-};
-/**
- * Returns a copy of the default modal config.
- * @returns a copy of the default modal config
- */
-export function getModalDefaultConfig() {
-    return { ...defaultConfig };
-}
-const modals$ = registrationArray();
-const hasModals$ = computed(() => modals$().length > 0);
-const scrollbarsAction$ = computed(() => {
-    if (hasModals$()) {
-        removeScrollbars();
-    }
-    else {
-        revertScrollbars();
-    }
-});
-const modalsAction$ = computed(() => {
-    scrollbarsAction$();
-});
-/**
- * Creates a new modal widget instance.
- * @param config$ - config of the modal, either as a store or as an object containing values or stores.
- * @returns a new modal widget instance
- */
-export function createModal(config$) {
-    const [{ animation$, backdrop$, backdropTransition$, closeOnOutsideClick$, container$, modalTransition$, onBeforeClose$, onVisibleChange$, onHidden$, onShown$, visible$: requestedVisible$, ...stateProps }, patch,] = writablesForProps(defaultConfig, config$, configValidator);
-    const modalTransition = createTransition({
-        props: {
-            transition: modalTransition$,
-            visible: requestedVisible$,
-            animation: animation$,
-            animationOnInit: animation$,
-            onVisibleChange: onVisibleChange$,
-            // TODO: for onHidden and onShown, should we combine with information from the backdrop transition?
-            // (especially in case one of the two transitions takes more time than the other)
-            onHidden: onHidden$,
-            onShown: onShown$,
-        },
-    });
-    const visible$ = modalTransition.stores.visible$;
-    const backdropTransition = createTransition({
-        props: {
-            transition: backdropTransition$,
-            visible: requestedVisible$,
-            animation: animation$,
-            animationOnInit: animation$,
-        },
-    });
-    const transitioning$ = computed(() => modalTransition.stores.transitioning$() || (backdrop$() && backdropTransition.stores.transitioning$()));
-    const hidden$ = computed(() => !transitioning$() && !visible$());
-    const backdropHidden$ = computed(() => !backdrop$() || hidden$());
-    let hideResult;
-    const close = (result) => {
-        hideResult = result;
-        const beforeCloseEvent = {
-            get result() {
-                return hideResult;
-            },
-            set result(value) {
-                hideResult = value;
-            },
-            cancel: false,
-        };
-        onBeforeClose$()(beforeCloseEvent);
-        if (beforeCloseEvent.cancel) {
-            return;
-        }
-        patch({ visible: false });
-    };
-    const modalPortalDirective = bindDirective(portal, computed(() => ({ container: container$() })));
-    const backdropPortalDirective = bindDirective(portal, computed(() => {
-        const container = container$();
-        const element = container ? modalTransition.stores.element$() : undefined;
-        return {
-            container,
-            insertBefore: element?.parentElement === container ? element : undefined,
-        };
-    }));
-    const registerModalAction$ = readable(undefined, () => modals$.register(res));
-    const action$ = computed(() => {
-        if (modalTransition.stores.elementPresent$() && !hidden$()) {
-            registerModalAction$();
-        }
-        modalsAction$();
-    });
-    const res = {
-        ...stateStores({
-            backdropHidden$,
-            container$,
-            hidden$,
-            transitioning$,
-            visible$,
-            modalElement$: modalTransition.stores.element$,
-            ...stateProps,
-        }),
-        directives: {
-            modalPortalDirective,
-            backdropPortalDirective,
-            backdropDirective: bindDirectiveNoArg(backdropTransition.directives.directive),
-            modalDirective: mergeDirectives(bindDirectiveNoArg(modalTransition.directives.directive), sliblingsInert, directiveSubscribe(action$)),
-        },
-        patch,
-        api: {
-            close,
-            async open() {
-                patch({ visible: true });
-                await promiseFromStore(hidden$).promise;
-                return hideResult;
-            },
-            patch,
-        },
-        actions: {
-            modalClick(event) {
-                if (event.currentTarget === event.target && closeOnOutsideClick$()) {
-                    close(modalOutsideClick);
-                }
-            },
-            closeButtonClick(event) {
-                close(modalCloseButtonClick);
-            },
-        },
-    };
-    return res;
-}

package/components/pagination/bootstrap.d.ts

@@ -1,8 +0,0 @@
-/**
- * This is the pagination algorithm used by ng-bootstrap. While this is not the default implementation of our widget, we export it to ease the migration from ng-bootstrap pagination.
- * @param maxSize - the max size
- * @param rotate - rotate the pages
- * @param ellipses - enable ellipses
- * @returns the pages
- */
-export declare function ngBootstrapPagination(maxSize: number, rotate: boolean, ellipses: boolean): (page: number, pageCount: number) => number[];