@agnos-ui/core 0.2.0 → 0.3.0

package/directive-DCYlDznf.js

@@ -0,0 +1,405 @@
+import { readable, writable, asReadable, batch } from "@amadeus-it-group/tansu";
+import { BROWSER } from "esm-env";
+import { n as noop } from "./func-DR0n-ShK.js";
+import { toReadableStore } from "./utils/stores.js";
+const computeCommonAncestor = (elements) => {
+  const length = elements.length;
+  if (length === 0)
+    return null;
+  let ancestor = elements[0];
+  for (let i = 1; i < length && ancestor; i++) {
+    const element = elements[i];
+    while (ancestor) {
+      if (ancestor === element) {
+        break;
+      }
+      const comparison = ancestor.compareDocumentPosition(element);
+      if (comparison & Node.DOCUMENT_POSITION_CONTAINED_BY) {
+        break;
+      } else if (comparison & Node.DOCUMENT_POSITION_CONTAINS) {
+        ancestor = element;
+        break;
+      } else if (comparison & Node.DOCUMENT_POSITION_DISCONNECTED) {
+        return null;
+      }
+      ancestor = ancestor.parentElement;
+    }
+  }
+  return ancestor;
+};
+const reflow = BROWSER ? (element = document.body) => {
+  if (isBrowserHTMLElement(element)) {
+    element.getBoundingClientRect();
+  }
+} : noop;
+const addClasses = (element, classes) => {
+  if (classes && classes.length > 0) {
+    element.classList.add(...classes);
+  }
+};
+const removeClasses = (element, classes) => {
+  if (classes && classes.length > 0) {
+    element.classList.remove(...classes);
+  }
+};
+function addEvent(element, type, fn, options) {
+  element.addEventListener(type, fn, options);
+  return function() {
+    element.removeEventListener(type, fn, options);
+  };
+}
+let idCount = 0;
+const generateId = () => `auId-${idCount++}`;
+const notEmpty = (value) => value != null && value !== false;
+function classNamesSubscribe(node, classNames$) {
+  let currentClassNames = /* @__PURE__ */ new Set();
+  return classNames$.subscribe((newClassName) => {
+    const classNames = new Set(`${newClassName ?? ""}`.split(" "));
+    classNames.delete("");
+    const classList = node.classList;
+    for (const className of currentClassNames) {
+      if (!classNames.has(className)) {
+        classList.remove(className);
+      }
+    }
+    if (classNames.size > 0) {
+      classList.add(...classNames);
+    }
+    currentClassNames = classNames;
+  });
+}
+function attributeSubscribe(node, attributeName, value$) {
+  return value$.subscribe((value) => {
+    if (notEmpty(value)) {
+      node.setAttribute(attributeName, "" + (value === true ? attributeName : value));
+    } else {
+      node.removeAttribute(attributeName);
+    }
+  });
+}
+function bindAttribute(node, attributeName, value$) {
+  const isClass = attributeName === "class";
+  return isClass ? classNamesSubscribe(node, value$) : attributeSubscribe(node, attributeName, value$);
+}
+function bindStyle(node, styleName, value$) {
+  return value$.subscribe((value) => {
+    const style = node.style;
+    style[styleName] = "" + (notEmpty(value) ? value : "");
+  });
+}
+function bindClassName(node, className, value$) {
+  const unsubscribe = value$.subscribe((isPresent) => {
+    node.classList.toggle(className, isPresent);
+  });
+  return () => {
+    unsubscribe();
+    node.classList.remove(className);
+  };
+}
+const ssrHTMLElementAttributesAndStyle = Symbol("attributesAndStyle");
+const spaceRegExp = /\s+/;
+const ssrHTMLElement = () => {
+  const attributes = {};
+  const style = {};
+  let classNames = /* @__PURE__ */ new Set();
+  const toggleClass = (className, force = !classNames.has(className)) => {
+    if (force) {
+      classNames.add(className);
+    } else {
+      classNames.delete(className);
+    }
+    return !!force;
+  };
+  const toggleAll = (force) => (...classNames2) => classNames2.forEach((className) => toggleClass(className, force));
+  return {
+    style,
+    classList: {
+      add: toggleAll(true),
+      remove: toggleAll(false),
+      toggle: toggleClass
+    },
+    setAttribute(name, value) {
+      if (name === "class") {
+        classNames = new Set(value.trim().split(spaceRegExp));
+      } else if (name === "style") {
+        throw new Error('setAttribute("style",...) is not implemented in ssrHTMLElement. Use the style property instead.');
+      } else {
+        attributes[name] = value;
+      }
+    },
+    removeAttribute(name) {
+      if (name === "class") {
+        classNames = /* @__PURE__ */ new Set();
+      } else {
+        delete attributes[name];
+      }
+    },
+    [ssrHTMLElementAttributesAndStyle]() {
+      return { attributes: { ...attributes }, classNames: [...classNames], style: { ...style } };
+    }
+  };
+};
+const isBrowserHTMLElement = BROWSER ? (element) => {
+  var _a;
+  const contentWindow = ((_a = element == null ? void 0 : element.ownerDocument) == null ? void 0 : _a.defaultView) ?? window;
+  return element instanceof contentWindow.HTMLElement;
+} : (element) => false;
+const browserDirective = BROWSER ? (directive) => (node, args) => {
+  if (isBrowserHTMLElement(node)) {
+    return directive(node, args);
+  }
+} : (directive) => () => {
+};
+const bindDirective = (directive, directiveArg$) => (element) => {
+  let firstTime = true;
+  let instance;
+  const unsubscribe = directiveArg$.subscribe((value) => {
+    var _a;
+    if (firstTime) {
+      firstTime = false;
+      instance = directive(element, value);
+    } else {
+      (_a = instance == null ? void 0 : instance.update) == null ? void 0 : _a.call(instance, value);
+    }
+  });
+  return {
+    destroy() {
+      var _a;
+      (_a = instance == null ? void 0 : instance.destroy) == null ? void 0 : _a.call(instance);
+      unsubscribe();
+    }
+  };
+};
+const noArg = readable(void 0);
+const bindDirectiveNoArg = (directive) => bindDirective(directive, noArg);
+const mapDirectiveArg = (directive, fn) => (node, arg) => {
+  const instance = directive(node, fn(arg));
+  return {
+    update: (arg2) => {
+      var _a;
+      (_a = instance == null ? void 0 : instance.update) == null ? void 0 : _a.call(instance, fn(arg2));
+    },
+    destroy: () => {
+      var _a;
+      return (_a = instance == null ? void 0 : instance.destroy) == null ? void 0 : _a.call(instance);
+    }
+  };
+};
+const directiveSubscribe = (store, asyncUnsubscribe = true) => () => {
+  const unsubscribe = store.subscribe(noop);
+  return {
+    destroy: async () => {
+      if (asyncUnsubscribe) {
+        await 0;
+      }
+      unsubscribe();
+    }
+  };
+};
+const directiveUpdate = (update) => (element, arg) => {
+  update(arg);
+  return {
+    update
+  };
+};
+const equalOption = { equal: Object.is };
+const registrationArray = () => {
+  const elements$ = writable([], equalOption);
+  return asReadable(elements$, {
+    /**
+     * Add the given element to the array.
+     * @param element - Element to be added to the array.
+     * @returns A function to remove the element from the array.
+     */
+    register: (element) => {
+      let removed = false;
+      elements$.update((currentElements) => [...currentElements, element]);
+      return () => {
+        if (!removed) {
+          removed = true;
+          elements$.update((currentElements) => {
+            const index = currentElements.indexOf(element);
+            if (index > -1) {
+              const copy = [...currentElements];
+              copy.splice(index, 1);
+              return copy;
+            }
+            return currentElements;
+          });
+        }
+      };
+    }
+  });
+};
+const createStoreArrayDirective = () => {
+  const elements$ = registrationArray();
+  return {
+    elements$: asReadable(elements$),
+    directive: (element) => ({ destroy: elements$.register(element) })
+  };
+};
+const createBrowserStoreArrayDirective = () => {
+  const { directive, elements$ } = createStoreArrayDirective();
+  return { directive: browserDirective(directive), elements$ };
+};
+const createStoreDirective = () => {
+  const element$ = writable(null, equalOption);
+  return {
+    element$: asReadable(element$),
+    directive: (element) => {
+      let valid = false;
+      element$.update((currentElement) => {
+        if (currentElement) {
+          console.error("The directive cannot be used on multiple elements.", currentElement, element);
+          return currentElement;
+        }
+        valid = true;
+        return element;
+      });
+      return valid ? {
+        destroy() {
+          element$.update((currentElement) => element === currentElement ? null : currentElement);
+        }
+      } : void 0;
+    }
+  };
+};
+const createBrowserStoreDirective = () => {
+  const { directive, element$ } = createStoreDirective();
+  return { directive: browserDirective(directive), element$ };
+};
+const mergeDirectives = (...args) => (element, arg) => {
+  const instances = batch(() => args.map((directive) => directive(element, arg)));
+  return {
+    update(arg2) {
+      batch(() => instances.forEach((instance) => {
+        var _a;
+        return (_a = instance == null ? void 0 : instance.update) == null ? void 0 : _a.call(instance, arg2);
+      }));
+    },
+    destroy() {
+      batch(() => instances.reverse().forEach((instance) => {
+        var _a;
+        return (_a = instance == null ? void 0 : instance.destroy) == null ? void 0 : _a.call(instance);
+      }));
+    }
+  };
+};
+const multiDirective = (element, directives) => {
+  const instances = [];
+  const update = (directives2) => batch(() => {
+    directives2.forEach((directiveWithArg, index) => {
+      var _a, _b, _c, _d;
+      const [directive, arg] = Array.isArray(directiveWithArg) ? directiveWithArg : [directiveWithArg, void 0];
+      const oldInstance = instances[index];
+      if (oldInstance) {
+        if (oldInstance.directive === directive) {
+          if (oldInstance.arg !== arg) {
+            (_b = (_a = oldInstance.instance) == null ? void 0 : _a.update) == null ? void 0 : _b.call(_a, arg);
+            oldInstance.arg = arg;
+          }
+          return;
+        }
+        (_d = (_c = oldInstance.instance) == null ? void 0 : _c.destroy) == null ? void 0 : _d.call(_c);
+      }
+      const instance = directive(element, arg);
+      instances[index] = { directive, instance, arg };
+    });
+    const extraInstances = instances.splice(directives2.length);
+    extraInstances.reverse().forEach(({ instance }) => {
+      var _a;
+      return (_a = instance == null ? void 0 : instance.destroy) == null ? void 0 : _a.call(instance);
+    });
+  });
+  update(directives);
+  return {
+    update,
+    destroy: () => update([])
+  };
+};
+const createAttributesDirective = (propsFn) => (node, args) => {
+  const unsubscribers = [];
+  const args$ = writable(args);
+  const { events, attributes, styles, classNames } = propsFn(args$);
+  if (isBrowserHTMLElement(node)) {
+    for (const [type, event] of Object.entries(events ?? {})) {
+      if (typeof event === "function") {
+        unsubscribers.push(addEvent(node, type, event));
+      } else {
+        unsubscribers.push(addEvent(node, type, event.handler, event.options));
+      }
+    }
+  }
+  for (const [attributeName, value] of Object.entries(attributes ?? {})) {
+    if (value != null) {
+      unsubscribers.push(bindAttribute(node, attributeName, toReadableStore(value)));
+    }
+  }
+  for (const [styleName, value] of Object.entries(styles ?? {})) {
+    if (value) {
+      unsubscribers.push(bindStyle(node, styleName, toReadableStore(value)));
+    }
+  }
+  for (const [className, value] of Object.entries(classNames ?? {})) {
+    unsubscribers.push(bindClassName(node, className, toReadableStore(value)));
+  }
+  return {
+    update: (args2) => args$.set(args2),
+    destroy: () => unsubscribers.forEach((fn) => fn())
+  };
+};
+const attributesData = (...directives) => {
+  const instances = [];
+  try {
+    const element = ssrHTMLElement();
+    for (const directive of directives) {
+      instances.push(Array.isArray(directive) ? directive[0](element, directive[1]) : directive(element));
+    }
+    return element[ssrHTMLElementAttributesAndStyle]();
+  } finally {
+    instances.forEach((instance) => {
+      var _a;
+      return (_a = instance == null ? void 0 : instance.destroy) == null ? void 0 : _a.call(instance);
+    });
+  }
+};
+const classDirective = createAttributesDirective((className) => ({ attributes: { class: className } }));
+function directiveAttributes(...directives) {
+  const { attributes, classNames, style } = attributesData(...directives);
+  if (classNames.length) {
+    attributes["class"] = classNames.join(" ");
+  }
+  const stringStyle = Object.entries(style).filter(([, value]) => !!value).map(([name, value]) => `${name}: ${value};`).join("");
+  if (stringStyle.length) {
+    attributes["style"] = stringStyle;
+  }
+  return attributes;
+}
+const ssrAttributes = BROWSER ? () => ({}) : directiveAttributes;
+export {
+  bindDirective as a,
+  browserDirective as b,
+  bindDirectiveNoArg as c,
+  directiveSubscribe as d,
+  directiveUpdate as e,
+  createStoreArrayDirective as f,
+  createBrowserStoreArrayDirective as g,
+  createStoreDirective as h,
+  isBrowserHTMLElement as i,
+  createBrowserStoreDirective as j,
+  mergeDirectives as k,
+  multiDirective as l,
+  mapDirectiveArg as m,
+  createAttributesDirective as n,
+  attributesData as o,
+  classDirective as p,
+  directiveAttributes as q,
+  registrationArray as r,
+  ssrAttributes as s,
+  generateId as t,
+  addEvent as u,
+  removeClasses as v,
+  addClasses as w,
+  reflow as x,
+  computeCommonAncestor as y
+};

package/func-DR0n-ShK.js

@@ -0,0 +1,7 @@
+const noop = () => {
+};
+const identity = (x) => x;
+export {
+  identity as i,
+  noop as n
+};

package/func-Qd3cD9a3.cjs

@@ -0,0 +1,6 @@
+"use strict";
+const noop = () => {
+};
+const identity = (x) => x;
+exports.identity = identity;
+exports.noop = noop;

package/index.cjs

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("./types.cjs");
+const accordion = require("./accordion-BuIgxZ0S.cjs");
+const common = require("./common-nJRMXbwj.cjs");
+const alert = require("./alert-C4jCg9Pl.cjs");
+const modal = require("./modal-rzMpATf5.cjs");
+const pagination = require("./pagination-EWSWQT1I.cjs");
+const progressbar = require("./progressbar-DH7DHYMp.cjs");
+const rating = require("./rating-CmuYUSxy.cjs");
+const select = require("./select-CCIKn8WR.cjs");
+const slider = require("./slider-DsLvT87U.cjs");
+const toast = require("./toast-Aw8o0Iwe.cjs");
+const config = require("./config.cjs");
+const services_extendWidget = require("./services/extendWidget.cjs");
+const services_floatingUI = require("./services/floatingUI.cjs");
+const services_focustrack = require("./services/focustrack.cjs");
+const services_intersection = require("./services/intersection.cjs");
+const services_matchMedia = require("./services/matchMedia.cjs");
+const services_navManager = require("./services/navManager.cjs");
+const services_portal = require("./services/portal.cjs");
+const services_resizeObserver = require("./services/resizeObserver.cjs");
+const services_siblingsInert = require("./services/siblingsInert.cjs");
+const services_transitions_baseTransitions = require("./services/transitions/baseTransitions.cjs");
+const services_transitions_cssTransitions = require("./services/transitions/cssTransitions.cjs");
+const services_transitions_simpleClassTransition = require("./services/transitions/simpleClassTransition.cjs");
+const utils_directive = require("./directive-BTSEYLF3.cjs");
+const utils_stores = require("./utils/stores.cjs");
+const utils_writables = require("./writables-D46sFgGK.cjs");
+exports.INVALID_VALUE = types.INVALID_VALUE;
+exports.toSlotContextWidget = types.toSlotContextWidget;
+exports.createAccordion = accordion.createAccordion;
+exports.createAccordionItem = accordion.createAccordionItem;
+exports.factoryCreateAccordion = accordion.factoryCreateAccordion;
+exports.getAccordionDefaultConfig = accordion.getAccordionDefaultConfig;
+exports.commonAlertConfigValidator = common.commonAlertConfigValidator;
+exports.createCommonAlert = common.createCommonAlert;
+exports.defaultCommonAlertConfig = common.defaultCommonAlertConfig;
+exports.getCommonAlertDefaultConfig = common.getCommonAlertDefaultConfig;
+exports.createAlert = alert.createAlert;
+exports.getAlertDefaultConfig = alert.getAlertDefaultConfig;
+exports.createModal = modal.createModal;
+exports.getModalDefaultConfig = modal.getModalDefaultConfig;
+exports.modalCloseButtonClick = modal.modalCloseButtonClick;
+exports.modalOutsideClick = modal.modalOutsideClick;
+exports.createPagination = pagination.createPagination;
+exports.getPaginationDefaultConfig = pagination.getPaginationDefaultConfig;
+exports.createProgressbar = progressbar.createProgressbar;
+exports.getProgressbarDefaultConfig = progressbar.getProgressbarDefaultConfig;
+exports.createRating = rating.createRating;
+exports.getRatingDefaultConfig = rating.getRatingDefaultConfig;
+exports.createSelect = select.createSelect;
+exports.defaultConfig = select.defaultConfig;
+exports.getSelectDefaultConfig = select.getSelectDefaultConfig;
+exports.createSlider = slider.createSlider;
+exports.getSliderDefaultConfig = slider.getSliderDefaultConfig;
+exports.createToast = toast.createToast;
+exports.getToastDefaultConfig = toast.getToastDefaultConfig;
+exports.createWidgetsConfig = config.createWidgetsConfig;
+exports.mergeInto = config.mergeInto;
+exports.extendWidgetProps = services_extendWidget.extendWidgetProps;
+exports.createFloatingUI = services_floatingUI.createFloatingUI;
+exports.activeElement$ = services_focustrack.activeElement$;
+exports.createHasFocus = services_focustrack.createHasFocus;
+exports.createIntersection = services_intersection.createIntersection;
+exports.createMatchMedia = services_matchMedia.createMatchMedia;
+exports.createNavManager = services_navManager.createNavManager;
+exports.getKeyName = services_navManager.getKeyName;
+exports.isInternalInputNavigation = services_navManager.isInternalInputNavigation;
+exports.portal = services_portal.portal;
+exports.createResizeObserver = services_resizeObserver.createResizeObserver;
+exports.sliblingsInert = services_siblingsInert.sliblingsInert;
+exports.createTransition = services_transitions_baseTransitions.createTransition;
+exports.noAnimation = services_transitions_baseTransitions.noAnimation;
+exports.createCSSTransition = services_transitions_cssTransitions.createCSSTransition;
+exports.getTransitionDurationMs = services_transitions_cssTransitions.getTransitionDurationMs;
+exports.hasTransition = services_transitions_cssTransitions.hasTransition;
+exports.createSimpleClassTransition = services_transitions_simpleClassTransition.createSimpleClassTransition;
+exports.attributesData = utils_directive.attributesData;
+exports.bindDirective = utils_directive.bindDirective;
+exports.bindDirectiveNoArg = utils_directive.bindDirectiveNoArg;
+exports.browserDirective = utils_directive.browserDirective;
+exports.classDirective = utils_directive.classDirective;
+exports.createAttributesDirective = utils_directive.createAttributesDirective;
+exports.createBrowserStoreArrayDirective = utils_directive.createBrowserStoreArrayDirective;
+exports.createBrowserStoreDirective = utils_directive.createBrowserStoreDirective;
+exports.createStoreArrayDirective = utils_directive.createStoreArrayDirective;
+exports.createStoreDirective = utils_directive.createStoreDirective;
+exports.directiveAttributes = utils_directive.directiveAttributes;
+exports.directiveSubscribe = utils_directive.directiveSubscribe;
+exports.directiveUpdate = utils_directive.directiveUpdate;
+exports.isBrowserHTMLElement = utils_directive.isBrowserHTMLElement;
+exports.mapDirectiveArg = utils_directive.mapDirectiveArg;
+exports.mergeDirectives = utils_directive.mergeDirectives;
+exports.multiDirective = utils_directive.multiDirective;
+exports.registrationArray = utils_directive.registrationArray;
+exports.ssrAttributes = utils_directive.ssrAttributes;
+exports.bindableDerived = utils_stores.bindableDerived;
+exports.bindableProp = utils_stores.bindableProp;
+exports.createPatch = utils_stores.createPatch;
+exports.findChangedProperties = utils_stores.findChangedProperties;
+exports.isStore = utils_stores.isStore;
+exports.mergeConfigStores = utils_stores.mergeConfigStores;
+exports.normalizeConfigStores = utils_stores.normalizeConfigStores;
+exports.stateStores = utils_stores.stateStores;
+exports.toReadableStore = utils_stores.toReadableStore;
+exports.toWritableStore = utils_stores.toWritableStore;
+exports.writableWithDefault = utils_stores.writableWithDefault;
+exports.writablesForProps = utils_stores.writablesForProps;
+exports.writablesWithDefault = utils_stores.writablesWithDefault;
+exports.testToNormalizeValue = utils_writables.testToNormalizeValue;
+exports.typeArray = utils_writables.typeArray;
+exports.typeBoolean = utils_writables.typeBoolean;
+exports.typeBooleanOrNull = utils_writables.typeBooleanOrNull;
+exports.typeFunction = utils_writables.typeFunction;
+exports.typeHTMLElementOrNull = utils_writables.typeHTMLElementOrNull;
+exports.typeNumber = utils_writables.typeNumber;
+exports.typeNumberInRangeFactory = utils_writables.typeNumberInRangeFactory;
+exports.typeString = utils_writables.typeString;

package/index.d.ts

@@ -14,6 +14,7 @@ export * from './services/extendWidget';
 export * from './services/floatingUI';
 export * from './services/focustrack';
 export * from './services/intersection';
+export * from './services/matchMedia';
 export * from './services/navManager';
 export * from './services/portal';
 export * from './services/resizeObserver';
@@ -21,7 +22,6 @@ export * from './services/siblingsInert';
 export * from './services/transitions/baseTransitions';
 export * from './services/transitions/cssTransitions';
 export * from './services/transitions/simpleClassTransition';
-export * from './services/transitions/bootstrap';
 export * from './utils/directive';
 export * from './utils/stores';
 export * from './utils/writables';