@design-factory/angular 21.0.3 → 21.1.0-next.0

package/node_modules/@agnos-ui/core/modal-CgzY8ezz.js

@@ -0,0 +1,253 @@
+import { computed, readable } from "@amadeus-it-group/tansu";
+import { b as typeBoolean, e as typeFunction, j as typeString, f as typeHTMLElementOrNull } from "./writables-DYGjj5T3.js";
+import { writablesForProps, stateStores } from "./utils/stores.js";
+import { createTransition } from "./services/transitions/baseTransitions.js";
+import { p as promiseFromStore } from "./promise-D-RZVPuv.js";
+import { noop } from "./utils/func.js";
+import { r as removeScrollbars, a as revertScrollbars } from "./scrollbars-CcxSrnCx.js";
+import { u as registrationArray, b as bindDirective, g as createAttributesDirective, d as browserDirective, s as mergeDirectives, o as directiveSubscribe, c as bindDirectiveNoArg } from "./directive-Bsreu2z1.js";
+import { portal } from "./services/portal.js";
+import { siblingsInert } from "./services/siblingsInert.js";
+import { createWidgetFactory } from "./utils/widget.js";
+import { focusElement } from "./services/focusElement.js";
+const modalOutsideClick = /* @__PURE__ */ Symbol();
+const modalCloseButtonClick = /* @__PURE__ */ Symbol();
+const modalCloseEscape = /* @__PURE__ */ Symbol();
+const defaultConfig = {
+  animated: true,
+  ariaCloseButtonLabel: "Close",
+  backdrop: true,
+  backdropClass: "",
+  backdropTransition: noop,
+  closeButton: true,
+  closeOnOutsideClick: true,
+  container: typeof window !== "undefined" ? document.body : null,
+  className: "",
+  modalTransition: noop,
+  onBeforeClose: noop,
+  onVisibleChange: noop,
+  onHidden: noop,
+  onShown: noop,
+  visible: false
+};
+const configValidator = {
+  animated: 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
+};
+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$();
+});
+const createModal = createWidgetFactory(
+  "modal",
+  (config$) => {
+    const [
+      {
+        animated$,
+        backdrop$,
+        backdropTransition$,
+        closeOnOutsideClick$,
+        container$,
+        modalTransition$,
+        onBeforeClose$,
+        onVisibleChange$,
+        onHidden$,
+        onShown$,
+        ariaCloseButtonLabel$,
+        className$,
+        backdropClass$,
+        visible$: requestedVisible$,
+        ...stateProps
+      },
+      patch
+    ] = writablesForProps(defaultConfig, config$, configValidator);
+    const modalTransition = createTransition({
+      props: {
+        transition: modalTransition$,
+        visible: requestedVisible$,
+        animated: animated$,
+        animatedOnInit: animated$,
+        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$,
+        animated: animated$,
+        animatedOnInit: animated$
+      }
+    });
+    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$() : void 0;
+        return {
+          container,
+          insertBefore: element?.parentElement === container ? element : void 0
+        };
+      })
+    );
+    const registerModalAction$ = readable(void 0, () => modals$.register(res));
+    const action$ = computed(() => {
+      if (modalTransition.stores.elementPresent$() && !hidden$()) {
+        registerModalAction$();
+      }
+      modalsAction$();
+    });
+    const closeButtonDirective = createAttributesDirective(() => ({
+      attributes: {
+        type: readable("button"),
+        "aria-label": ariaCloseButtonLabel$
+      },
+      events: {
+        click: () => close(modalCloseButtonClick)
+      }
+    }));
+    const backdropAttributeDirective = createAttributesDirective(() => ({
+      attributes: {
+        class: backdropClass$
+      }
+    }));
+    const modalAttributeDirective = createAttributesDirective(() => ({
+      attributes: {
+        class: className$,
+        tabIndex: readable("-1")
+      },
+      events: {
+        click: (event) => {
+          if (event.currentTarget === event.target && closeOnOutsideClick$()) {
+            close(modalOutsideClick);
+          }
+        },
+        keydown: (event) => {
+          const { key } = event;
+          switch (key) {
+            case "Escape":
+              close(modalCloseEscape);
+              event.stopPropagation();
+              break;
+          }
+        }
+      }
+    }));
+    const res = {
+      ...stateStores({
+        backdropHidden$,
+        container$,
+        hidden$,
+        transitioning$,
+        visible$,
+        modalElement$: modalTransition.stores.element$,
+        ariaCloseButtonLabel$,
+        className$,
+        backdropClass$,
+        ...stateProps
+      }),
+      directives: {
+        modalPortalDirective,
+        backdropPortalDirective,
+        backdropDirective: mergeDirectives(backdropTransition.directives.directive, backdropAttributeDirective),
+        modalDirective: mergeDirectives(
+          modalTransition.directives.directive,
+          bindDirectiveNoArg(siblingsInert),
+          directiveSubscribe(action$),
+          modalAttributeDirective,
+          focusElement
+        ),
+        closeButtonDirective,
+        dialogDirective: bindDirective(
+          browserDirective((dialog, visible) => {
+            const update = (visible2) => {
+              if (visible2) {
+                dialog.showModal();
+              } else {
+                dialog.close();
+              }
+            };
+            update(visible);
+            return {
+              update
+            };
+          }),
+          visible$
+        )
+      },
+      patch,
+      api: {
+        close,
+        async open() {
+          patch({ visible: true });
+          await promiseFromStore(hidden$).promise;
+          return hideResult;
+        },
+        patch
+      }
+    };
+    return res;
+  }
+);
+export {
+  modalCloseEscape as a,
+  modalOutsideClick as b,
+  createModal as c,
+  getModalDefaultConfig as g,
+  modalCloseButtonClick as m
+};

package/node_modules/@agnos-ui/core/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "@agnos-ui/core",
+	"description": "Framework-agnostic headless component library.",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"main": "./index.cjs",
+	"module": "./index.js",
+	"types": "./index.d.ts",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"require": "./index.cjs",
+			"default": "./index.js"
+		},
+		"./components/*": {
+			"types": "./components/*/index.d.ts",
+			"require": "./components/*/index.cjs",
+			"default": "./components/*/index.js"
+		},
+		"./config": {
+			"types": "./config.d.ts",
+			"require": "./config.cjs",
+			"default": "./config.js"
+		},
+		"./types": {
+			"types": "./types.d.ts",
+			"require": "./types.cjs",
+			"default": "./types.js"
+		},
+		"./services/*": {
+			"types": "./services/*.d.ts",
+			"require": "./services/*.cjs",
+			"default": "./services/*.js"
+		},
+		"./services/transitions/*": {
+			"types": "./services/transitions/*.d.ts",
+			"require": "./services/transitions/*.cjs",
+			"default": "./services/transitions/*.js"
+		},
+		"./utils/*": {
+			"types": "./utils/*.d.ts",
+			"require": "./utils/*.cjs",
+			"default": "./utils/*.js"
+		}
+	},
+	"dependencies": {
+		"clsx": "^2.1.1"
+	},
+	"peerDependencies": {
+		"@amadeus-it-group/tansu": "^2.0.0",
+		"@floating-ui/dom": "^1.6.12",
+		"embla-carousel": "^8.5.2",
+		"esm-env": "^1.2.1"
+	},
+	"sideEffects": false
+}

package/node_modules/@agnos-ui/core/pagination-ZxGaNWZz.js

@@ -0,0 +1,255 @@
+import { computed } from "@amadeus-it-group/tansu";
+import { writablesForProps, bindableProp, stateStores, true$ } from "./utils/stores.js";
+import { j as typeString, e as typeFunction, b as typeBoolean, g as typeNumber, l as clamp, m as isNumber } from "./writables-DYGjj5T3.js";
+import { noop } from "./utils/func.js";
+import { g as createAttributesDirective } from "./directive-Bsreu2z1.js";
+import { createWidgetFactory } from "./utils/widget.js";
+const PAGE_LINK_DEFAULT = "#";
+const defaultConfig = {
+  page: 1,
+  collectionSize: 0,
+  pageSize: 10,
+  disabled: false,
+  directionLinks: true,
+  boundaryLinks: false,
+  onPageChange: noop,
+  pagesFactory: (_page, pageCount) => {
+    const pages = [];
+    for (let i = 1; i <= pageCount; i++) {
+      pages.push(i);
+    }
+    return pages;
+  },
+  ariaLabel: "Page navigation",
+  activeLabel: "(current)",
+  ariaPageLabel: (processPage, pageCount) => `Page ${processPage} of ${pageCount}`,
+  ariaFirstLabel: "Action link for first page",
+  ariaPreviousLabel: "Action link for previous page",
+  ariaNextLabel: "Action link for next page",
+  ariaLastLabel: "Action link for last page",
+  ariaEllipsisLabel: "Ellipsis page element",
+  ariaLiveLabel: (currentPage) => `Current page is ${currentPage}`,
+  className: "",
+  pageLink: (_page) => PAGE_LINK_DEFAULT
+};
+function getPaginationDefaultConfig() {
+  return { ...defaultConfig };
+}
+const configValidator = {
+  page: typeNumber,
+  collectionSize: typeNumber,
+  pageSize: typeNumber,
+  disabled: typeBoolean,
+  directionLinks: typeBoolean,
+  boundaryLinks: typeBoolean,
+  onPageChange: typeFunction,
+  pagesFactory: typeFunction,
+  ariaLabel: typeString,
+  activeLabel: typeString,
+  ariaPageLabel: typeFunction,
+  ariaFirstLabel: typeString,
+  ariaPreviousLabel: typeString,
+  ariaNextLabel: typeString,
+  ariaLastLabel: typeString,
+  ariaLiveLabel: typeFunction,
+  className: typeString,
+  pageLink: typeFunction,
+  ariaEllipsisLabel: typeString
+};
+const createPagination = createWidgetFactory(
+  "pagination",
+  (config) => {
+    const [
+      {
+        // dirty inputs that need adjustment:
+        page$: _dirtyPage$,
+        // clean inputs with value validation:
+        collectionSize$,
+        pageSize$,
+        onPageChange$,
+        pagesFactory$,
+        ariaPageLabel$,
+        ariaLiveLabel$,
+        pageLink$,
+        disabled$,
+        ariaFirstLabel$,
+        ariaLastLabel$,
+        ariaNextLabel$,
+        ariaPreviousLabel$,
+        ...stateProps
+      },
+      patch
+    ] = writablesForProps(defaultConfig, config, configValidator);
+    const pageCount$ = computed(() => {
+      let pageCount = Math.ceil(collectionSize$() / pageSize$());
+      if (!isNumber(pageCount) || pageCount < 1) {
+        pageCount = 1;
+      }
+      return pageCount;
+    });
+    const page$ = bindableProp(_dirtyPage$, onPageChange$, (dirtyPage) => clamp(dirtyPage, pageCount$(), 1));
+    const pages$ = computed(() => pagesFactory$()(page$(), pageCount$()));
+    const nextDisabled$ = computed(() => page$() === pageCount$() || disabled$());
+    const previousDisabled$ = computed(() => page$() === 1 || disabled$());
+    const pagesLabel$ = computed(() => {
+      const ariaPageLabel = ariaPageLabel$();
+      const pageCount = pageCount$();
+      return pages$().map((page) => ariaPageLabel(page, pageCount));
+    });
+    const pagesHrefs$ = computed(() => {
+      const pageLinkFactory = pageLink$();
+      const pageCount = pageCount$();
+      return Array.from({ length: pageCount }, (_, index) => pageLinkFactory(index + 1));
+    });
+    const directionsHrefs$ = computed(() => {
+      const pagesHrefs = pagesHrefs$();
+      const pageIndex = page$() - 1;
+      return {
+        previous: pagesHrefs.at(pageIndex > 0 ? pageIndex - 1 : 0),
+        next: pagesHrefs.at(pageIndex + 1) ?? pagesHrefs.at(-1)
+      };
+    });
+    const ariaLiveLabelText$ = computed(() => ariaLiveLabel$()(page$(), pageCount$()));
+    function handleNavigation(pageNumber, event) {
+      if (pagesHrefs$()[pageNumber - 1] === PAGE_LINK_DEFAULT) {
+        event?.preventDefault();
+      }
+      if (!event || !(event.ctrlKey || event.metaKey)) {
+        event?.preventDefault();
+        page$.set(pageNumber);
+      }
+    }
+    const widget = {
+      ...stateStores({
+        pageCount$,
+        page$,
+        pages$,
+        nextDisabled$,
+        previousDisabled$,
+        pagesLabel$,
+        pagesHrefs$,
+        directionsHrefs$,
+        disabled$,
+        ariaFirstLabel$,
+        ariaLastLabel$,
+        ariaNextLabel$,
+        ariaPreviousLabel$,
+        ariaLiveLabelText$,
+        ...stateProps
+      }),
+      patch,
+      api: {
+        /**
+         * Set the current page pageNumber (starting from 1)
+         * @param pageNumber - Current page number to set.
+         * Value is normalized between 1 and the number of page
+         */
+        select(pageNumber) {
+          page$.set(pageNumber);
+        },
+        /**
+         * Select the first page
+         */
+        first() {
+          page$.set(1);
+        },
+        /**
+         * Select the previous page
+         */
+        previous() {
+          page$.update((p) => p - 1);
+        },
+        /**
+         * Select the next page
+         */
+        next() {
+          page$.update((p) => p + 1);
+        },
+        /**
+         * Select the last page
+         */
+        last() {
+          page$.set(pageCount$());
+        }
+      },
+      directives: {
+        pageLink: createAttributesDirective((pageLinkContext$) => ({
+          events: {
+            click: (e) => handleNavigation(pageLinkContext$().page, e)
+          },
+          attributes: {
+            "aria-current": computed(() => page$() === pageLinkContext$().page ? "page" : void 0),
+            "aria-label": computed(() => pagesLabel$()[pageLinkContext$().page - 1]),
+            href: computed(() => pagesHrefs$()[pageLinkContext$().page - 1]),
+            tabindex: computed(() => disabled$() ? "-1" : void 0),
+            "aria-disabled": computed(() => disabled$() ? "true" : void 0)
+          },
+          classNames: {
+            "au-page": true$
+          }
+        })),
+        pageFirst: createAttributesDirective(() => ({
+          events: {
+            click: (e) => handleNavigation(1, e)
+          },
+          attributes: {
+            "aria-label": ariaFirstLabel$,
+            href: computed(() => pagesHrefs$()[0]),
+            tabindex: computed(() => previousDisabled$() ? "-1" : void 0),
+            "aria-disabled": computed(() => previousDisabled$() ? "true" : void 0)
+          },
+          classNames: {
+            "au-first": true$
+          }
+        })),
+        pagePrev: createAttributesDirective(() => ({
+          events: {
+            click: (e) => handleNavigation(page$() - 1, e)
+          },
+          attributes: {
+            "aria-label": ariaPreviousLabel$,
+            href: computed(() => directionsHrefs$().previous),
+            tabindex: computed(() => previousDisabled$() ? "-1" : void 0),
+            "aria-disabled": computed(() => previousDisabled$() ? "true" : void 0)
+          },
+          classNames: {
+            "au-previous": true$
+          }
+        })),
+        pageNext: createAttributesDirective(() => ({
+          events: {
+            click: (e) => handleNavigation(page$() + 1, e)
+          },
+          attributes: {
+            "aria-label": ariaNextLabel$,
+            href: computed(() => directionsHrefs$().next),
+            tabindex: computed(() => nextDisabled$() ? "-1" : void 0),
+            "aria-disabled": computed(() => nextDisabled$() ? "true" : void 0)
+          },
+          classNames: {
+            "au-next": true$
+          }
+        })),
+        pageLast: createAttributesDirective(() => ({
+          events: {
+            click: (e) => handleNavigation(pageCount$(), e)
+          },
+          attributes: {
+            "aria-label": ariaLastLabel$,
+            href: computed(() => pagesHrefs$().at(-1)),
+            tabindex: computed(() => nextDisabled$() ? "-1" : void 0),
+            "aria-disabled": computed(() => nextDisabled$() ? "true" : void 0)
+          },
+          classNames: {
+            "au-last": true$
+          }
+        }))
+      }
+    };
+    return widget;
+  }
+);
+export {
+  createPagination as c,
+  getPaginationDefaultConfig as g
+};