@design-factory/core 21.1.0-next.1

package/pagination-BQWusWXN.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-CNNSo5Yn.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
+};

package/progressbar-RopgvVeA.cjs

@@ -0,0 +1,86 @@
+"use strict";
+const utils_writables = require("./writables-Dt68gADJ.cjs");
+const utils_stores = require("./utils/stores.cjs");
+const tansu = require("@amadeus-it-group/tansu");
+const utils_directive = require("./directive-DyTodNPd.cjs");
+const utils_widget = require("./utils/widget.cjs");
+const defaultConfig = {
+  min: 0,
+  max: 100,
+  value: 0,
+  ariaLabel: "Progressbar",
+  className: "",
+  ariaValueTextFn: () => void 0
+};
+function getProgressbarDefaultConfig() {
+  return { ...defaultConfig };
+}
+const configValidator = {
+  min: utils_writables.typeNumber,
+  max: utils_writables.typeNumber,
+  value: utils_writables.typeNumber,
+  ariaLabel: utils_writables.typeString,
+  className: utils_writables.typeString,
+  ariaValueTextFn: utils_writables.typeFunction
+};
+const createProgressbar = utils_widget.createWidgetFactory(
+  "progressbar",
+  (config) => {
+    const [
+      {
+        // dirty inputs that need adjustment:
+        max$: _dirtyMaximum$,
+        value$: _dirtyValue$,
+        // clean inputs
+        min$,
+        ariaValueTextFn$,
+        ariaLabel$,
+        ...stateProps
+      },
+      patch
+    ] = utils_stores.writablesForProps(defaultConfig, config, configValidator);
+    const max$ = tansu.computed(() => Math.max(min$(), _dirtyMaximum$()));
+    const value$ = tansu.computed(() => utils_writables.clamp(_dirtyValue$(), max$(), min$()));
+    const percentage$ = tansu.computed(() => {
+      const max = max$();
+      const min = min$();
+      if (max > min) {
+        return utils_writables.clamp((value$() - min) * 100 / (max - min), 100, 0);
+      } else {
+        return 0;
+      }
+    });
+    const started$ = tansu.computed(() => value$() > min$());
+    const finished$ = tansu.computed(() => value$() === max$());
+    const ariaValueText$ = tansu.computed(() => ariaValueTextFn$()(value$(), min$(), max$()));
+    return {
+      ...utils_stores.stateStores({
+        min$,
+        max$,
+        value$,
+        percentage$,
+        started$,
+        finished$,
+        ariaValueText$,
+        ariaLabel$,
+        ...stateProps
+      }),
+      patch,
+      api: {},
+      directives: {
+        ariaDirective: utils_directive.createAttributesDirective(() => ({
+          attributes: {
+            role: tansu.readable("progressbar"),
+            "aria-label": ariaLabel$,
+            "aria-valuenow": value$,
+            "aria-valuemin": min$,
+            "aria-valuemax": max$,
+            "aria-valuetext": ariaValueText$
+          }
+        }))
+      }
+    };
+  }
+);
+exports.createProgressbar = createProgressbar;
+exports.getProgressbarDefaultConfig = getProgressbarDefaultConfig;

package/progressbar-S1pNn5rM.js

@@ -0,0 +1,87 @@
+import { e as typeFunction, j as typeString, g as typeNumber, l as clamp } from "./writables-DYGjj5T3.js";
+import { writablesForProps, stateStores } from "./utils/stores.js";
+import { computed, readable } from "@amadeus-it-group/tansu";
+import { g as createAttributesDirective } from "./directive-CNNSo5Yn.js";
+import { createWidgetFactory } from "./utils/widget.js";
+const defaultConfig = {
+  min: 0,
+  max: 100,
+  value: 0,
+  ariaLabel: "Progressbar",
+  className: "",
+  ariaValueTextFn: () => void 0
+};
+function getProgressbarDefaultConfig() {
+  return { ...defaultConfig };
+}
+const configValidator = {
+  min: typeNumber,
+  max: typeNumber,
+  value: typeNumber,
+  ariaLabel: typeString,
+  className: typeString,
+  ariaValueTextFn: typeFunction
+};
+const createProgressbar = createWidgetFactory(
+  "progressbar",
+  (config) => {
+    const [
+      {
+        // dirty inputs that need adjustment:
+        max$: _dirtyMaximum$,
+        value$: _dirtyValue$,
+        // clean inputs
+        min$,
+        ariaValueTextFn$,
+        ariaLabel$,
+        ...stateProps
+      },
+      patch
+    ] = writablesForProps(defaultConfig, config, configValidator);
+    const max$ = computed(() => Math.max(min$(), _dirtyMaximum$()));
+    const value$ = computed(() => clamp(_dirtyValue$(), max$(), min$()));
+    const percentage$ = computed(() => {
+      const max = max$();
+      const min = min$();
+      if (max > min) {
+        return clamp((value$() - min) * 100 / (max - min), 100, 0);
+      } else {
+        return 0;
+      }
+    });
+    const started$ = computed(() => value$() > min$());
+    const finished$ = computed(() => value$() === max$());
+    const ariaValueText$ = computed(() => ariaValueTextFn$()(value$(), min$(), max$()));
+    return {
+      ...stateStores({
+        min$,
+        max$,
+        value$,
+        percentage$,
+        started$,
+        finished$,
+        ariaValueText$,
+        ariaLabel$,
+        ...stateProps
+      }),
+      patch,
+      api: {},
+      directives: {
+        ariaDirective: createAttributesDirective(() => ({
+          attributes: {
+            role: readable("progressbar"),
+            "aria-label": ariaLabel$,
+            "aria-valuenow": value$,
+            "aria-valuemin": min$,
+            "aria-valuemax": max$,
+            "aria-valuetext": ariaValueText$
+          }
+        }))
+      }
+    };
+  }
+);
+export {
+  createProgressbar as c,
+  getProgressbarDefaultConfig as g
+};

package/promise-CxCD3NYv.cjs

@@ -0,0 +1,118 @@
+"use strict";
+const tansu = require("@amadeus-it-group/tansu");
+const utils_func = require("./utils/func.cjs");
+const promisePending = { status: "pending" };
+const isThenable = (value) => {
+  const type = typeof value;
+  return type === "object" && value !== null || type === "function" ? typeof value.then === "function" : false;
+};
+const createPromiseStateStore = (promise) => {
+  const store = tansu.writable(promisePending);
+  Promise.resolve(promise).then(
+    (value) => store.set({ status: "fulfilled", value }),
+    (reason) => store.set({ status: "rejected", reason })
+  );
+  return tansu.asReadable(store);
+};
+const promiseWeakMap = /* @__PURE__ */ new WeakMap();
+const promiseStateStore = (value) => {
+  if (!isThenable(value)) {
+    return tansu.readable({ status: "fulfilled", value });
+  }
+  let response = promiseWeakMap.get(value);
+  if (!response) {
+    response = createPromiseStateStore(value);
+    promiseWeakMap.set(value, response);
+  }
+  return response;
+};
+const promiseStateStoreEqual = (a, b) => Object.is(a, b) || a.status === b.status && (a.status !== "fulfilled" || tansu.equal(a.value, b.value)) && (a.status !== "rejected" || tansu.equal(a.reason, b.reason));
+const promiseStoreToPromiseStateStore = (promiseStore$) => tansu.computed(() => promiseStateStore(promiseStore$())(), { equal: promiseStateStoreEqual });
+const promiseStateStoreToValueStore = (store$, initialValue, equal2) => tansu.derived(
+  store$,
+  {
+    derive: (state, set) => {
+      if (state.status === "fulfilled") {
+        set(state.value);
+      }
+    },
+    equal: equal2
+  },
+  initialValue
+);
+const promiseStoreToValueStore = (promiseStore$, initialValue, equal2) => promiseStateStoreToValueStore(promiseStoreToPromiseStateStore(promiseStore$), initialValue, equal2);
+const truthyValue = (value) => !!value;
+const promiseFromStore = (store, condition = truthyValue) => {
+  let resolve;
+  const promise = new Promise((r) => resolve = r);
+  let unsubscribe = () => {
+    storeUnsubscribe();
+    unsubscribe = utils_func.noop;
+  };
+  let storeUnsubscribe = utils_func.noop;
+  storeUnsubscribe = store.subscribe((value) => {
+    if (condition(value)) {
+      resolve(value);
+      unsubscribe();
+    }
+  });
+  if (unsubscribe === utils_func.noop) {
+    storeUnsubscribe();
+  }
+  return {
+    promise,
+    unsubscribe() {
+      unsubscribe();
+    }
+  };
+};
+const promiseFromEvent = (element, event) => {
+  let resolve;
+  const promise = new Promise((r) => resolve = r);
+  let unsubscribe = () => {
+    element.removeEventListener(event, eventListener);
+    unsubscribe = utils_func.noop;
+  };
+  const eventListener = (event2) => {
+    if (event2.target === element) {
+      resolve(event2);
+      unsubscribe();
+    }
+  };
+  element.addEventListener(event, eventListener);
+  return {
+    promise,
+    unsubscribe() {
+      unsubscribe();
+    }
+  };
+};
+const promiseFromTimeout = (delay) => {
+  let timeout;
+  return {
+    promise: new Promise((r) => {
+      timeout = setTimeout(() => {
+        timeout = void 0;
+        r();
+      }, delay);
+    }),
+    unsubscribe() {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = void 0;
+      }
+    }
+  };
+};
+const promiseWithResolve = () => {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+};
+exports.promiseFromEvent = promiseFromEvent;
+exports.promiseFromStore = promiseFromStore;
+exports.promiseFromTimeout = promiseFromTimeout;
+exports.promiseStoreToValueStore = promiseStoreToValueStore;
+exports.promiseWithResolve = promiseWithResolve;

package/promise-D-RZVPuv.js

@@ -0,0 +1,119 @@
+import { derived, computed, readable, equal, writable, asReadable } from "@amadeus-it-group/tansu";
+import { noop } from "./utils/func.js";
+const promisePending = { status: "pending" };
+const isThenable = (value) => {
+  const type = typeof value;
+  return type === "object" && value !== null || type === "function" ? typeof value.then === "function" : false;
+};
+const createPromiseStateStore = (promise) => {
+  const store = writable(promisePending);
+  Promise.resolve(promise).then(
+    (value) => store.set({ status: "fulfilled", value }),
+    (reason) => store.set({ status: "rejected", reason })
+  );
+  return asReadable(store);
+};
+const promiseWeakMap = /* @__PURE__ */ new WeakMap();
+const promiseStateStore = (value) => {
+  if (!isThenable(value)) {
+    return readable({ status: "fulfilled", value });
+  }
+  let response = promiseWeakMap.get(value);
+  if (!response) {
+    response = createPromiseStateStore(value);
+    promiseWeakMap.set(value, response);
+  }
+  return response;
+};
+const promiseStateStoreEqual = (a, b) => Object.is(a, b) || a.status === b.status && (a.status !== "fulfilled" || equal(a.value, b.value)) && (a.status !== "rejected" || equal(a.reason, b.reason));
+const promiseStoreToPromiseStateStore = (promiseStore$) => computed(() => promiseStateStore(promiseStore$())(), { equal: promiseStateStoreEqual });
+const promiseStateStoreToValueStore = (store$, initialValue, equal2) => derived(
+  store$,
+  {
+    derive: (state, set) => {
+      if (state.status === "fulfilled") {
+        set(state.value);
+      }
+    },
+    equal: equal2
+  },
+  initialValue
+);
+const promiseStoreToValueStore = (promiseStore$, initialValue, equal2) => promiseStateStoreToValueStore(promiseStoreToPromiseStateStore(promiseStore$), initialValue, equal2);
+const truthyValue = (value) => !!value;
+const promiseFromStore = (store, condition = truthyValue) => {
+  let resolve;
+  const promise = new Promise((r) => resolve = r);
+  let unsubscribe = () => {
+    storeUnsubscribe();
+    unsubscribe = noop;
+  };
+  let storeUnsubscribe = noop;
+  storeUnsubscribe = store.subscribe((value) => {
+    if (condition(value)) {
+      resolve(value);
+      unsubscribe();
+    }
+  });
+  if (unsubscribe === noop) {
+    storeUnsubscribe();
+  }
+  return {
+    promise,
+    unsubscribe() {
+      unsubscribe();
+    }
+  };
+};
+const promiseFromEvent = (element, event) => {
+  let resolve;
+  const promise = new Promise((r) => resolve = r);
+  let unsubscribe = () => {
+    element.removeEventListener(event, eventListener);
+    unsubscribe = noop;
+  };
+  const eventListener = (event2) => {
+    if (event2.target === element) {
+      resolve(event2);
+      unsubscribe();
+    }
+  };
+  element.addEventListener(event, eventListener);
+  return {
+    promise,
+    unsubscribe() {
+      unsubscribe();
+    }
+  };
+};
+const promiseFromTimeout = (delay) => {
+  let timeout;
+  return {
+    promise: new Promise((r) => {
+      timeout = setTimeout(() => {
+        timeout = void 0;
+        r();
+      }, delay);
+    }),
+    unsubscribe() {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = void 0;
+      }
+    }
+  };
+};
+const promiseWithResolve = () => {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+};
+export {
+  promiseStoreToValueStore as a,
+  promiseFromEvent as b,
+  promiseFromTimeout as c,
+  promiseWithResolve as d,
+  promiseFromStore as p
+};