@design-factory/core 21.1.0 → 22.0.0-next.1

package/utils/stores.d.ts

@@ -1,4 +1,4 @@
-import type { ReadableSignal, StoreInput, StoresInputValues, WritableSignal } from '@amadeus-it-group/tansu';
+import type { ReadableSignal, WritableSignal } from '@amadeus-it-group/tansu';
 import type { ConfigValidator, PropsConfig, ValuesOrReadableSignals, WritableWithDefaultOptions } from '../types';
 /**
  * Transforms the properties of a given type `P` into writable signals.
@@ -176,7 +176,7 @@ export declare const writablesWithDefault: <T extends object>(defConfig: T, prop
  * const [{propA$, propB$}, patch] = writablesForProps(defConfig, config, validation);
  * ```
  */
-export declare const writablesForProps: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T>, options?: { [K in keyof T]: WritableWithDefaultOptions<T[K]> | undefined; }) => [ToWritableSignal<T>, ReturnType<typeof createPatch<T>>];
+export declare const writablesForProps: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T>, options?: ConfigValidator<T>) => [ToWritableSignal<T>, ReturnType<typeof createPatch<T>>];
 /**
  * Using input stores, this function builds an object containing the stores as readable and a global state.
  *
@@ -188,20 +188,6 @@ export declare const stateStores: <A extends object>(inputStores: { [K in keyof
     state$: ReadableSignal<A>;
     stores: { [K in keyof A as `${K & string}$`]: ReadableSignal<A[K]>; };
 };
-/**
- * Creates a writable signal that derives its value from multiple stores and allows for custom adjustment and equality checks.
- *
- * @template T - The type of the derived value.
- * @template U - A tuple type where the first element is a writable signal of type T and the rest are store inputs.
- *
- * @param onChange$ - A readable signal that emits a function to be called when the derived value changes.
- * @param stores - A tuple of stores where the first element is a writable signal of type T and the rest are store inputs.
- * @param adjustValue - A function to adjust the derived value based on the input values from the stores.
- * @param equal - A function to compare the current and new values for equality.
- *
- * @returns A writable signal that derives its value from the provided stores and allows for custom adjustment and equality checks.
- */
-export declare const bindableDerived: <T, U extends [WritableSignal<T>, ...StoreInput<any>[]]>(onChange$: ReadableSignal<(value: T) => void>, stores: U, adjustValue?: (arg: StoresInputValues<U>) => T, equal?: (currentValue: T, newValue: T) => boolean) => WritableSignal<T>;
 /**
  * Creates a bindable property that synchronizes a writable signal with an optional adjustment function and equality check.
  *

package/utils/stores.js

@@ -1,4 +1,4 @@
-import { readable, equal, asWritable, derived, computed, batch, asReadable, get, writable } from "@amadeus-it-group/tansu";
+import { readable, equal, asWritable, computed, batch, asReadable, get, writable } from "@amadeus-it-group/tansu";
 import { INVALID_VALUE } from "../types.js";
 import { identity } from "./func.js";
 import { generateId } from "./id.js";
@@ -63,7 +63,10 @@ const normalizeConfigStores = (keys, config) => {
   if (config) {
     const configIsStore = isStore(config);
     for (const key of keys) {
-      res[key] = configIsStore ? computed(() => config()[key]) : toReadableStore(config[key]);
+      res[key] = configIsStore ? computed(() => config()[key]) : (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        toReadableStore(config[key])
+      );
     }
   }
   return res;
@@ -115,27 +118,6 @@ const stateStores = (inputStores) => {
     })
   };
 };
-const bindableDerived = (onChange$, stores, adjustValue = (arg) => arg[0], equal2 = (currentValue, newValue) => newValue === currentValue) => {
-  let currentValue = stores[0]();
-  return asWritable(
-    derived(stores, {
-      derive(values) {
-        const newValue = adjustValue(values);
-        const rectifiedValue = !equal2(values[0], newValue);
-        if (rectifiedValue) {
-          stores[0].set(newValue);
-        }
-        if (rectifiedValue || !equal2(currentValue, newValue)) {
-          currentValue = newValue;
-          onChange$()(newValue);
-        }
-        return newValue;
-      },
-      equal: equal2
-    }),
-    stores[0].set.bind(stores[0])
-  );
-};
 const bindableProp = (store$, onChange$, adjustValue = identity, equal$1 = equal) => asWritable(
   computed(() => adjustValue(store$()), { equal: equal$1 }),
   (newValue) => {
@@ -153,7 +135,6 @@ function idWithDefault(id$) {
 const true$ = readable(true);
 const false$ = readable(false);
 export {
-  bindableDerived,
   bindableProp,
   createPatch,
   false$,

package/utils/writables.d.ts

@@ -1,4 +1,4 @@
-import type { WritableWithDefaultOptions } from '../types';
+import type { PickRequired, WritableWithDefaultOptions } from '../types';
 import { INVALID_VALUE } from '../types';
 /**
  * Check if a value respects a provided type guard.
@@ -9,11 +9,11 @@ import { INVALID_VALUE } from '../types';
  * @returns A function that takes a value and returns the value if it passes the filter,
  *          otherwise returns `INVALID_VALUE`.
  */
-export declare const testToNormalizeValue: <T>(filter: (value: any) => value is T) => ((value: any) => T | typeof INVALID_VALUE);
+export declare const testToNormalizeValue: <T>(filter: (value: unknown) => value is T) => ((value: unknown) => T | typeof INVALID_VALUE);
 /**
  * A writable object with default options for handling numbers.
  */
-export declare const typeNumber: WritableWithDefaultOptions<number>;
+export declare const typeNumber: PickRequired<WritableWithDefaultOptions<number>, 'normalizeValue'>;
 /**
  * Options for specifying the behavior of number range validation.
  */
@@ -32,7 +32,7 @@ export interface TypeNumberInRangeOptions {
  *
  * @returns A type guard function that returns the clamp value or INVALID_VALUE depending on the provided options.
  */
-export declare function typeNumberInRangeFactory(min: number, max: number, options?: TypeNumberInRangeOptions): WritableWithDefaultOptions<number>;
+export declare function typeNumberInRangeFactory(min: number, max: number, options?: TypeNumberInRangeOptions): PickRequired<WritableWithDefaultOptions<number>, 'normalizeValue'>;
 /**
  * A writable object with default options for boolean values.
  *
@@ -41,39 +41,39 @@ export declare function typeNumberInRangeFactory(min: number, max: number, optio
  * function ensures that the value is properly validated and normalized
  * as a boolean.
  */
-export declare const typeBoolean: WritableWithDefaultOptions<boolean>;
+export declare const typeBoolean: PickRequired<WritableWithDefaultOptions<boolean>, 'normalizeValue'>;
 /**
  * A writable with default options that normalizes its value to a boolean or null.
  *
  * This writable uses a normalization function that allows null values and ensures
  * the value is a boolean.
  */
-export declare const typeBooleanOrNull: WritableWithDefaultOptions<boolean | null>;
+export declare const typeBooleanOrNull: PickRequired<WritableWithDefaultOptions<boolean | null>, 'normalizeValue'>;
 /**
  * A writable object with default options for string values.
  *
  * This object provides a normalized value for strings using the `testToNormalizeValue` function
  * with the `isString` validator.
  */
-export declare const typeString: WritableWithDefaultOptions<string>;
+export declare const typeString: PickRequired<WritableWithDefaultOptions<string>, 'normalizeValue'>;
 /**
  * A writable with default options that normalizes its value to a string or null.
  *
  * This object provides a normalized value for strings using the `testToNormalizeValue` function
  * with the `isString` validator.
  */
-export declare const typeStringOrNull: WritableWithDefaultOptions<string | null>;
+export declare const typeStringOrNull: PickRequired<WritableWithDefaultOptions<string | null>, 'normalizeValue'>;
 /**
  * A writable with default options that normalizes its value to a number or null.
  *
  * This writable uses a normalization function that allows null values and ensures
  * the value is a boolean.
  */
-export declare const typeNumberOrNull: WritableWithDefaultOptions<number | null>;
+export declare const typeNumberOrNull: PickRequired<WritableWithDefaultOptions<number | null>, 'normalizeValue'>;
 /**
  * A writable object that holds a function type with default options.
  */
-export declare const typeFunction: WritableWithDefaultOptions<(...args: any[]) => any>;
+export declare const typeFunction: PickRequired<WritableWithDefaultOptions<(...args: any[]) => any>, 'normalizeValue' | 'equal'>;
 /**
  * A writable object with default options for handling values of type `HTMLElement` or `null`.
  *
@@ -81,15 +81,29 @@ export declare const typeFunction: WritableWithDefaultOptions<(...args: any[]) =
  * - `normalizeValue`: A function to normalize the value, ensuring it is either an `HTMLElement` or `null`.
  * - `equal`: A function to compare two values for equality using `Object.is`.
  */
-export declare const typeHTMLElementOrNull: WritableWithDefaultOptions<HTMLElement | null>;
+export declare const typeHTMLElementOrNull: PickRequired<WritableWithDefaultOptions<HTMLElement | null>, 'normalizeValue' | 'equal'>;
 /**
  * A writable object with default options for handling arrays.
  */
-export declare const typeArray: WritableWithDefaultOptions<any[]>;
+export declare const typeArray: PickRequired<WritableWithDefaultOptions<any[]>, 'normalizeValue' | 'equal'>;
 /**
  * Build an enum normalizer
  * @template T - the enum type
  * @param enumList - list of enum values to check
  * @returns the enum normalizer
  */
-export declare function createTypeEnum<T>(enumList: T[]): WritableWithDefaultOptions<T>;
+export declare function createTypeEnum<T>(enumList: T[]): PickRequired<WritableWithDefaultOptions<T>, 'normalizeValue'>;
+/**
+ * Build a normalizer for space-separated string values.
+ *
+ * Accepts either a `T[]` array or a space-separated string (e.g. `"a b c"`).
+ * Each item is validated through the provided `normalizeItem` function, which
+ * may return a single value, an array of values (allowing one token to expand
+ * into multiple items), or `INVALID_VALUE` to reject the input.
+ *
+ * @template T - The string literal union type of valid items.
+ * @param normalizeItem - A function that validates and normalizes a single item string
+ *                        into one or more `T` values, or returns `INVALID_VALUE` if invalid.
+ * @returns A `WritableWithDefaultOptions` that normalizes `T[] | string` into `T[]`.
+ */
+export declare function createTypeStringSpacedArray<T>(normalizeItem: (value: string) => T | T[] | typeof INVALID_VALUE): PickRequired<WritableWithDefaultOptions<T[]>, 'normalizeValue' | 'equal'>;

package/utils/writables.js

@@ -1,16 +1,17 @@
-import { c, t, a, b, d, e, f, g, h, i, j, k } from "../writables-DYGjj5T3.js";
+import { c, a, t, b, d, e, f, g, h, i, j, k, l } from "../writables-_7BriMb2.js";
 import "../types.js";
 export {
   c as createTypeEnum,
+  a as createTypeStringSpacedArray,
   t as testToNormalizeValue,
-  a as typeArray,
-  b as typeBoolean,
-  d as typeBooleanOrNull,
-  e as typeFunction,
-  f as typeHTMLElementOrNull,
-  g as typeNumber,
-  h as typeNumberInRangeFactory,
-  i as typeNumberOrNull,
-  j as typeString,
-  k as typeStringOrNull
+  b as typeArray,
+  d as typeBoolean,
+  e as typeBooleanOrNull,
+  f as typeFunction,
+  g as typeHTMLElementOrNull,
+  h as typeNumber,
+  i as typeNumberInRangeFactory,
+  j as typeNumberOrNull,
+  k as typeString,
+  l as typeStringOrNull
 };

package/{writables-DYGjj5T3.js → writables-_7BriMb2.js}

@@ -85,19 +85,44 @@ function createTypeEnum(enumList) {
     normalizeValue: testToNormalizeValue(isFromEnum(enumList))
   };
 }
+function createTypeStringSpacedArray(normalizeItem) {
+  return {
+    normalizeValue: (value) => {
+      const trimmed = isString(value) ? value.trim() : void 0;
+      const items = trimmed !== void 0 ? trimmed === "" ? [] : trimmed.split(/\s+/) : isArray(value) ? value : void 0;
+      if (!items) {
+        return INVALID_VALUE;
+      }
+      const result = [];
+      for (const item of items) {
+        const normalized = normalizeItem(item);
+        if (normalized === INVALID_VALUE) {
+          return INVALID_VALUE;
+        } else if (isArray(normalized)) {
+          result.push(...normalized);
+        } else {
+          result.push(normalized);
+        }
+      }
+      return result;
+    },
+    equal: typeArray.equal
+  };
+}
 export {
-  typeArray as a,
-  typeBoolean as b,
+  createTypeStringSpacedArray as a,
+  typeArray as b,
   createTypeEnum as c,
-  typeBooleanOrNull as d,
-  typeFunction as e,
-  typeHTMLElementOrNull as f,
-  typeNumber as g,
-  typeNumberInRangeFactory as h,
-  typeNumberOrNull as i,
-  typeString as j,
-  typeStringOrNull as k,
-  clamp as l,
-  isNumber as m,
+  typeBoolean as d,
+  typeBooleanOrNull as e,
+  typeFunction as f,
+  typeHTMLElementOrNull as g,
+  typeNumber as h,
+  typeNumberInRangeFactory as i,
+  typeNumberOrNull as j,
+  typeString as k,
+  typeStringOrNull as l,
+  clamp as m,
+  isNumber as n,
   testToNormalizeValue as t
 };

package/accordion-B0vs8JWM.cjs

@@ -1,314 +0,0 @@
-"use strict";
-const utils_stores = require("./utils/stores.cjs");
-const services_transitions_baseTransitions = require("./services/transitions/baseTransitions.cjs");
-const tansu = require("@amadeus-it-group/tansu");
-const utils_func = require("./utils/func.cjs");
-const utils_writables = require("./writables-Dt68gADJ.cjs");
-const utils_directive = require("./directive-DyTodNPd.cjs");
-const utils_widget = require("./utils/widget.cjs");
-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) {
-    keepOpen = openItems[0];
-  }
-  if (keepOpen) {
-    items.forEach((item) => {
-      if (item.stores.id$() !== keepOpen && item.stores.visible$()) {
-        item.patch({ visible: false });
-      }
-    });
-  }
-  return items;
-}
-function getItem(items, id) {
-  return items.find((item) => item.stores.id$() === id);
-}
-const defaultAccordionConfig = {
-  closeOthers: false,
-  onItemShown: utils_func.noop,
-  onItemHidden: utils_func.noop,
-  className: "",
-  itemDestroyOnHide: true,
-  itemAnimated: true,
-  itemTransition: utils_func.noop,
-  itemHeadingLevel: 2,
-  itemClassName: "",
-  itemHeaderClassName: "",
-  itemButtonClassName: "",
-  itemBodyContainerClassName: "",
-  itemBodyClassName: ""
-};
-const defaultItemConfig = {
-  id: "",
-  destroyOnHide: defaultAccordionConfig.itemDestroyOnHide,
-  disabled: false,
-  visible: false,
-  animated: defaultAccordionConfig.itemAnimated,
-  transition: defaultAccordionConfig.itemTransition,
-  onShown: utils_func.noop,
-  onHidden: utils_func.noop,
-  onVisibleChange: utils_func.noop,
-  className: defaultAccordionConfig.itemClassName,
-  headerClassName: defaultAccordionConfig.itemHeaderClassName,
-  buttonClassName: defaultAccordionConfig.itemButtonClassName,
-  bodyContainerClassName: defaultAccordionConfig.itemBodyContainerClassName,
-  bodyClassName: defaultAccordionConfig.itemBodyClassName,
-  headingLevel: defaultAccordionConfig.itemHeadingLevel
-};
-const coreAccordionItemProps = Object.keys(defaultItemConfig);
-function getAccordionDefaultConfig() {
-  return { ...defaultAccordionConfig };
-}
-const configAccordionValidator = {
-  closeOthers: utils_writables.typeBoolean,
-  onItemShown: utils_writables.typeFunction,
-  onItemHidden: utils_writables.typeFunction,
-  className: utils_writables.typeString,
-  itemDestroyOnHide: utils_writables.typeBoolean,
-  itemAnimated: utils_writables.typeBoolean,
-  itemTransition: utils_writables.typeFunction,
-  itemClassName: utils_writables.typeString,
-  itemHeaderClassName: utils_writables.typeString,
-  itemButtonClassName: utils_writables.typeString,
-  itemBodyContainerClassName: utils_writables.typeString,
-  itemBodyClassName: utils_writables.typeString,
-  itemHeadingLevel: utils_writables.createTypeEnum([1, 2, 3, 4, 5, 6])
-};
-const configItemValidator = {
-  id: utils_writables.typeString,
-  destroyOnHide: utils_writables.typeBoolean,
-  disabled: utils_writables.typeBoolean,
-  visible: utils_writables.typeBoolean,
-  animated: utils_writables.typeBoolean,
-  transition: utils_writables.typeFunction,
-  onShown: utils_writables.typeFunction,
-  onHidden: utils_writables.typeFunction,
-  onVisibleChange: utils_writables.typeFunction,
-  className: utils_writables.typeString,
-  headerClassName: utils_writables.typeString,
-  buttonClassName: utils_writables.typeString,
-  bodyContainerClassName: utils_writables.typeString,
-  bodyClassName: utils_writables.typeString,
-  headingLevel: utils_writables.createTypeEnum([1, 2, 3, 4, 5, 6])
-};
-function createAccordionItem(config) {
-  const [
-    {
-      bodyClassName$,
-      buttonClassName$,
-      bodyContainerClassName$,
-      headerClassName$,
-      animated$,
-      transition$,
-      destroyOnHide$,
-      onShown$,
-      onHidden$,
-      onVisibleChange$,
-      visible$,
-      id$: _dirtyId$,
-      disabled$,
-      ...stateProps
-    },
-    patch
-  ] = utils_stores.writablesForProps(defaultItemConfig, config, configItemValidator);
-  const initDone$ = tansu.writable(false);
-  const id$ = utils_stores.idWithDefault(_dirtyId$);
-  const transition = services_transitions_baseTransitions.createTransition({
-    props: {
-      transition: transition$,
-      visible: visible$,
-      onVisibleChange: onVisibleChange$,
-      animated: animated$,
-      animatedOnInit: false,
-      initDone: initDone$,
-      onHidden: () => {
-        onHidden$()();
-      },
-      onShown: () => {
-        onShown$()();
-      }
-    }
-  });
-  const shouldBeInDOM$ = tansu.computed(() => !destroyOnHide$() || !transition.stores.hidden$());
-  const toggleDirective = utils_directive.createAttributesDirective(() => ({
-    attributes: {
-      id: tansu.computed(() => `${id$()}-toggle`),
-      "aria-expanded": tansu.computed(() => `${visible$()}`),
-      "aria-disabled": tansu.computed(() => `${disabled$()}`),
-      "aria-controls": tansu.computed(() => `${id$()}-body-container`),
-      disabled: disabled$
-    },
-    classNames: { collapsed: tansu.computed(() => !visible$()) },
-    events: {
-      click: () => {
-        if (!disabled$()) {
-          void transition.api.toggle();
-        }
-      }
-    }
-  }));
-  const transitionDirective = transition.directives.directive;
-  const bodyContainerAttrsDirective = utils_directive.createAttributesDirective(() => ({
-    attributes: {
-      id: tansu.computed(() => `${id$()}-body-container`),
-      class: bodyContainerClassName$,
-      "aria-labelledby": tansu.computed(() => `${id$()}-toggle`),
-      role: tansu.readable("region")
-    }
-  }));
-  return {
-    ...utils_stores.stateStores({
-      visible$,
-      id$,
-      shouldBeInDOM$,
-      disabled$,
-      bodyClassName$,
-      buttonClassName$,
-      bodyContainerClassName$,
-      headerClassName$,
-      ...stateProps
-    }),
-    patch,
-    api: {
-      initDone: () => {
-        initDone$.set(true);
-      },
-      collapse: transition.api.hide,
-      expand: transition.api.show,
-      toggle: (animated) => transition.api.toggle(void 0, animated)
-    },
-    directives: {
-      toggleDirective,
-      buttonDirective: utils_directive.mergeDirectives(
-        toggleDirective,
-        utils_directive.createAttributesDirective(() => ({
-          attributes: {
-            type: tansu.readable("button"),
-            class: buttonClassName$
-          }
-        }))
-      ),
-      headerDirective: utils_directive.createAttributesDirective(() => ({ attributes: { class: headerClassName$ } })),
-      bodyDirective: utils_directive.createAttributesDirective(() => ({ attributes: { class: bodyClassName$ } })),
-      transitionDirective,
-      bodyContainerAttrsDirective,
-      bodyContainerDirective: utils_directive.mergeDirectives(transitionDirective, bodyContainerAttrsDirective),
-      itemDirective: utils_func.noop
-    }
-  };
-}
-function factoryCreateAccordion(itemFactory = createAccordionItem, accordionItemProps = coreAccordionItemProps, accordionConfig = defaultAccordionConfig, accordionValidator = configAccordionValidator) {
-  return utils_widget.createWidgetFactory("accordion", (config) => {
-    const [writables, patch] = utils_stores.writablesForProps(accordionConfig, config, accordionValidator);
-    const { closeOthers$, onItemShown$, onItemHidden$, className$ } = writables;
-    const accordionItemConfig = Object.fromEntries(
-      Object.entries(writables).filter((entry) => entry[0].startsWith("item")).map((entry) => [entry[0].charAt(4).toLowerCase() + entry[0].slice(5, -1), entry[1]])
-    );
-    const itemWidgets$ = utils_directive.registrationArray();
-    const openItems$ = tansu.computed(() => {
-      const openItems = [];
-      itemWidgets$().forEach((item) => {
-        if (item.stores.visible$()) {
-          openItems.push(item.stores.id$());
-        }
-      });
-      return openItems;
-    });
-    const oldOpenItem$ = tansu.writable(openItems$()[0]);
-    const checkCloseOthersAction$ = tansu.computed(() => {
-      if (closeOthers$()) {
-        adjustItemsCloseOthers(itemWidgets$(), openItems$(), oldOpenItem$());
-        oldOpenItem$.set(openItems$()[0]);
-      }
-    });
-    const action$ = tansu.computed(() => {
-      checkCloseOthersAction$();
-    });
-    return {
-      ...utils_stores.stateStores({ itemWidgets$, className$ }),
-      patch,
-      api: {
-        expand: async (id, animated) => {
-          await getItem(itemWidgets$(), id)?.api.expand(animated);
-        },
-        collapse: async (id, animated) => {
-          await getItem(itemWidgets$(), id)?.api.collapse(animated);
-        },
-        toggle: async (id, animated) => {
-          await getItem(itemWidgets$(), id)?.api.toggle(animated);
-        },
-        expandAll: async (animated) => {
-          await Promise.all(itemWidgets$().map((i) => i.api.expand(animated)));
-        },
-        collapseAll: async (animated) => {
-          await Promise.all(itemWidgets$().map((i) => i.api.collapse(animated)));
-        },
-        registerItem: (propsConfig) => {
-          const itemProps = accordionItemProps;
-          const config2 = utils_stores.mergeConfigStores(
-            itemProps,
-            utils_stores.normalizeConfigStores(itemProps, propsConfig?.config),
-            accordionItemConfig
-          );
-          const [{ onHidden$, onShown$ }] = utils_stores.writablesForProps(
-            {
-              onHidden: defaultItemConfig.onHidden,
-              onShown: defaultItemConfig.onShown
-            },
-            { config: config2, props: propsConfig?.props }
-          );
-          const item = itemFactory({
-            config: config2,
-            props: {
-              ...propsConfig?.props,
-              onHidden: tansu.asWritable(
-                tansu.readable(() => {
-                  onItemHidden$()(item.stores.id$());
-                  onHidden$()?.();
-                }),
-                (val) => {
-                  onItemHidden$.set(val);
-                }
-              ),
-              onShown: tansu.asWritable(
-                tansu.readable(() => {
-                  onItemShown$()(item.stores.id$());
-                  onShown$()?.();
-                }),
-                (val) => {
-                  onItemShown$.set(val);
-                }
-              )
-            }
-          });
-          item.directives.itemDirective = utils_directive.mergeDirectives(
-            () => ({
-              destroy: itemWidgets$.register(item)
-            }),
-            utils_directive.createAttributesDirective(() => ({
-              attributes: { class: item.stores.className$, id: item.stores.id$ }
-            }))
-          );
-          return item;
-        }
-      },
-      directives: {
-        accordionDirective: utils_directive.mergeDirectives(
-          utils_directive.directiveSubscribe(action$),
-          utils_directive.createAttributesDirective(() => ({
-            attributes: { class: className$ },
-            classNames: { "au-accordion": utils_stores.true$ }
-          }))
-        )
-      }
-    };
-  });
-}
-const createAccordion = factoryCreateAccordion();
-exports.createAccordion = createAccordion;
-exports.createAccordionItem = createAccordionItem;
-exports.factoryCreateAccordion = factoryCreateAccordion;
-exports.getAccordionDefaultConfig = getAccordionDefaultConfig;

package/alert-AhaliJ17.cjs

@@ -1,9 +0,0 @@
-"use strict";
-const common = require("./common-B5jS-Ih_.cjs");
-const utils_widget = require("./utils/widget.cjs");
-function getAlertDefaultConfig() {
-  return { ...common.getCommonAlertDefaultConfig() };
-}
-const createAlert = utils_widget.createWidgetFactory("alert", common.createCommonAlert);
-exports.createAlert = createAlert;
-exports.getAlertDefaultConfig = getAlertDefaultConfig;

package/alert-Cb9FhbFQ.js

@@ -1,10 +0,0 @@
-import { g as getCommonAlertDefaultConfig, c as createCommonAlert } from "./common-DFyZvkII.js";
-import { createWidgetFactory } from "./utils/widget.js";
-function getAlertDefaultConfig() {
-  return { ...getCommonAlertDefaultConfig() };
-}
-const createAlert = createWidgetFactory("alert", createCommonAlert);
-export {
-  createAlert as c,
-  getAlertDefaultConfig as g
-};