@limetech/lime-elements 40.18.3 → 40.20.0

package/dist/collection/util/controlled-element.js

@@ -0,0 +1,22 @@
+/**
+ * Says that `owner` controls the element with the given id, for example the
+ * list that a field opens. An id only finds elements in the same DOM tree, so
+ * where the browser allows it, the element itself is referenced instead.
+ *
+ * @param owner - The element that controls the other one.
+ * @param id - The id of the controlled element, which may not exist yet.
+ * `null` says that nothing is controlled.
+ */
+export const setControlledElement = (owner, id) => {
+    if ('ariaControlsElements' in owner) {
+        // eslint-disable-next-line unicorn/prefer-query-selector
+        const controlled = id ? document.getElementById(id) : null;
+        owner.ariaControlsElements = controlled ? [controlled] : null;
+        return;
+    }
+    if (id) {
+        owner.setAttribute('aria-controls', id);
+        return;
+    }
+    owner.removeAttribute('aria-controls');
+};

package/dist/collection/util/live-message.js

@@ -0,0 +1,30 @@
+import { debounce } from "lodash-es";
+const LIVE_MESSAGE_DELAY = 500;
+/**
+ * Creates what a component needs to speak a message through a visually hidden
+ * element with `aria-live`. The text is written straight into that element
+ * and not through the state of the component, so speaking costs no render.
+ * It is written a short while after the last update, so that a screen reader
+ * does not read out every change while the user is typing.
+ *
+ * @param getMessage - Returns the text to speak. An empty text clears the
+ * element, so that the same message is spoken again the next time.
+ * @returns `setElement`, to be used as the `ref` of the live element, and
+ * `update`, to be called when the message may have changed.
+ */
+export const createLiveMessage = (getMessage) => {
+    let element;
+    const setElement = (liveElement) => {
+        element = liveElement;
+    };
+    const update = debounce(() => {
+        if (!element) {
+            return;
+        }
+        const message = getMessage();
+        if (element.textContent !== message) {
+            element.textContent = message;
+        }
+    }, LIVE_MESSAGE_DELAY);
+    return { setElement, update };
+};

package/dist/esm/controlled-element-ByOXsysp.js

@@ -0,0 +1,24 @@
+/**
+ * Says that `owner` controls the element with the given id, for example the
+ * list that a field opens. An id only finds elements in the same DOM tree, so
+ * where the browser allows it, the element itself is referenced instead.
+ *
+ * @param owner - The element that controls the other one.
+ * @param id - The id of the controlled element, which may not exist yet.
+ * `null` says that nothing is controlled.
+ */
+const setControlledElement = (owner, id) => {
+    if ('ariaControlsElements' in owner) {
+        // eslint-disable-next-line unicorn/prefer-query-selector
+        const controlled = id ? document.getElementById(id) : null;
+        owner.ariaControlsElements = controlled ? [controlled] : null;
+        return;
+    }
+    if (id) {
+        owner.setAttribute('aria-controls', id);
+        return;
+    }
+    owner.removeAttribute('aria-controls');
+};
+
+export { setControlledElement as s };

package/dist/esm/{index-BN64nlbO.js → index-CofmbCdQ.js}

@@ -214,7 +214,7 @@ function trough() {
 
       // Next or done.
       if (fn) {
-        wrap(fn, next)(...output);
+        wrap$1(fn, next)(...output);
       } else {
         callback(null, ...output);
       }
@@ -242,7 +242,7 @@ function trough() {
  * @param {Middleware} middleware
  * @param {Callback} callback
  */
-function wrap(middleware, callback) {
+function wrap$1(middleware, callback) {
   /** @type {boolean} */
   let called;
 
@@ -19931,16 +19931,19 @@ function looksLikeANode(value) {
 }
 
 /**
+ * Color a string.
+ *
  * @param {string} d
+ *   Value.
  * @returns {string}
+ *   Colored value.
  */
 function color(d) {
   return d
 }
 
 /**
- * @typedef {import('unist').Node} UnistNode
- * @typedef {import('unist').Parent} UnistParent
+ * @import {Node as UnistNode, Parent as UnistParent} from 'unist'
  */
 
 
@@ -19959,6 +19962,7 @@ const EXIT = false;
 
 /**
  * Do not traverse this node’s children.
+ * Only works when entering a node.
  */
 const SKIP = 'skip';
 
@@ -19966,10 +19970,13 @@ const SKIP = 'skip';
  * Visit nodes, with ancestral information.
  *
  * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+ * (**NLR**) or if `reverse` is given,
+ * in *reverse preorder* (**NRL**).
+ * An `exit` visitor is called in *postorder* (**LRN**)
+ * or if `reverse` is given, in *reverse postorder* (**RLN**).
  *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
+ * You can choose which nodes are visited by passing a `test`.
+ * For complex tests, you should test yourself in a visitor, as it will be
  * faster and will have improved type information.
  *
  * Walking the tree is an intensive task.
@@ -19978,29 +19985,72 @@ const SKIP = 'skip';
  * to check if a node matches, and then perform different operations.
  *
  * You can change the tree.
- * See `Visitor` for more info.
+ * Changes inside a node made when entering it are walked,
+ * changes made when exiting it are not.
+ * See `Visitor` and `VisitorExit` for more info.
  *
  * @overload
  * @param {Tree} tree
+ *   Tree to traverse.
  * @param {Check} check
- * @param {BuildVisitor<Tree, Check>} visitor
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitor<Tree, Check>} enter
+ *   Handle each node when entering it.
+ * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+ * @returns {undefined}
+ *   Nothing.
+ *
+ * @overload
+ * @param {Tree} tree
+ *   Tree to traverse.
+ * @param {Check} check
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitors<Tree, Check>} visitors
+ *   Handle each node when exiting it, and optionally when entering it.
+ * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+ * @returns {undefined}
+ *   Nothing.
+ *
+ * @overload
+ * @param {Tree} tree
+ *   Tree to traverse.
+ * @param {BuildVisitor<Tree>} enter
+ *   Handle each node when entering it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @overload
  * @param {Tree} tree
- * @param {BuildVisitor<Tree>} visitor
+ *   Tree to traverse.
+ * @param {BuildVisitors<Tree>} visitors
+ *   Handle each node when exiting it, and optionally when entering it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @param {UnistNode} tree
  *   Tree to traverse.
- * @param {Visitor | Test} test
- *   `unist-util-is`-compatible test
- * @param {Visitor | boolean | null | undefined} [visitor]
- *   Handle each node.
+ * @param {Visitor | Visitors | Test} testOrEnterOrVisitors
+ *   `unist-util-is`-compatible test, `enter`, or `visitors`.
+ * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]
+ *   `enter`, `visitors`, or `reverse` after a test.
  * @param {boolean | null | undefined} [reverse]
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
  *   Nothing.
  *
@@ -20009,28 +20059,87 @@ const SKIP = 'skip';
  * @template {Test} Check
  *   `unist-util-is`-compatible test.
  */
-function visitParents(tree, test, visitor, reverse) {
+function visitParents(
+  tree,
+  testOrEnterOrVisitors,
+  enterOrVisitorsOrReverse,
+  reverse
+) {
+  if (!tree || typeof tree !== 'object') {
+    throw new Error('Unexpected value `' + tree + '` for `tree`, expected node')
+  }
+
+  let preorder = true;
   /** @type {Test} */
   let check;
+  /** @type {Visitors | Visitor} */
+  let visitors;
+  /** @type {Visitor | null | undefined} */
+  let enter;
+  /** @type {VisitorExit | null | undefined} */
+  let exit;
+
+  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.
+  if (
+    typeof enterOrVisitorsOrReverse === 'function' ||
+    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')
+  ) {
+    check = /** @type {Test} */ (testOrEnterOrVisitors);
+    visitors = enterOrVisitorsOrReverse;
+    if (reverse) preorder = false;
+  }
+  // Assume no test.
+  else {
+    visitors = /** @type {Visitors | Visitor} */ (testOrEnterOrVisitors);
+    if (enterOrVisitorsOrReverse) preorder = false;
+  }
+
+  if (typeof visitors === 'function') {
+    enter = visitors;
+  } else if (visitors && typeof visitors === 'object') {
+    if (visitors.enter === null || visitors.enter === undefined) ; else if (typeof visitors.enter === 'function') {
+      enter = visitors.enter;
+    } else {
+      throw new Error(
+        'Unexpected value `' +
+          visitors.enter +
+          '` for `visitors.enter`, expected optional visitor'
+      )
+    }
 
-  if (typeof test === 'function' && typeof visitor !== 'function') {
-    reverse = visitor;
-    // @ts-expect-error no visitor given, so `visitor` is test.
-    visitor = test;
+    if (typeof visitors.exit === 'function') {
+      exit = visitors.exit;
+    } else {
+      throw new Error(
+        'Unexpected value `' +
+          visitors.exit +
+          '` for `visitors.exit`, expected visitor (pass a visitor directly if you only want an enter visitor)'
+      )
+    }
   } else {
-    // @ts-expect-error visitor given, so `test` isn’t a visitor.
-    check = test;
+    throw new Error(
+      'Unexpected value `' +
+        visitors +
+        '` for `enter` or `visitors`, expected visitor or object with visitors'
+    )
   }
 
   const is = convert(check);
-  const step = reverse ? -1 : 1;
+  const step = preorder ? 1 : -1;
 
   factory(tree, undefined, [])();
 
   /**
+   * Create a function to visit a node.
+   *
    * @param {UnistNode} node
+   *   Node to visit.
    * @param {number | undefined} index
+   *   Index of `node` in its parent.
    * @param {Array<UnistParent>} parents
+   *   Ancestors of `node`.
+   * @returns {() => Readonly<ActionTuple>}
+   *   Visit `node`.
    */
   function factory(node, index, parents) {
     const value = /** @type {Record<string, unknown>} */ (
@@ -20043,9 +20152,9 @@ function visitParents(tree, test, visitor, reverse) {
         typeof value.tagName === 'string'
           ? value.tagName
           : // `xast`
-          typeof value.name === 'string'
-          ? value.name
-          : undefined;
+            typeof value.name === 'string'
+            ? value.name
+            : undefined;
 
       Object.defineProperty(visit, 'name', {
         value:
@@ -20056,18 +20165,13 @@ function visitParents(tree, test, visitor, reverse) {
     return visit
 
     function visit() {
+      const matches =
+        !check || is(node, index, parents[parents.length - 1] || undefined);
       /** @type {Readonly<ActionTuple>} */
       let result = empty;
-      /** @type {Readonly<ActionTuple>} */
-      let subresult;
-      /** @type {number} */
-      let offset;
-      /** @type {Array<UnistParent>} */
-      let grandparents;
 
-      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
-        // @ts-expect-error: `visitor` is now a visitor.
-        result = toResult(visitor(node, parents));
+      if (enter && matches) {
+        result = toResult(enter(node, parents, index));
 
         if (result[0] === EXIT) {
           return result
@@ -20078,13 +20182,13 @@ function visitParents(tree, test, visitor, reverse) {
         const nodeAsParent = /** @type {UnistParent} */ (node);
 
         if (nodeAsParent.children && result[0] !== SKIP) {
-          offset = (reverse ? nodeAsParent.children.length : -1) + step;
-          grandparents = parents.concat(nodeAsParent);
+          let offset = (preorder ? -1 : nodeAsParent.children.length) + step;
+          const grandparents = [...parents, nodeAsParent];
 
           while (offset > -1 && offset < nodeAsParent.children.length) {
             const child = nodeAsParent.children[offset];
 
-            subresult = factory(child, offset, grandparents)();
+            const subresult = factory(child, offset, grandparents)();
 
             if (subresult[0] === EXIT) {
               return subresult
@@ -20096,6 +20200,23 @@ function visitParents(tree, test, visitor, reverse) {
         }
       }
 
+      if (exit && matches) {
+        const exitResult = toResult(exit(node, parents, index));
+
+        if (exitResult[0] === SKIP) {
+          throw new Error(
+            'Unexpected value `' +
+              exitResult[0] +
+              '` from `exit`, expected `CONTINUE`, `EXIT`, index, or nothing'
+          )
+        }
+
+        // Prefer a result from `exit` over `enter`.
+        if (exitResult[0] === EXIT || typeof exitResult[1] === 'number') {
+          return exitResult
+        }
+      }
+
       return result
     }
   }
@@ -20123,7 +20244,13 @@ function toResult(value) {
 
 /**
  * @import {Node as UnistNode, Parent as UnistParent} from 'unist'
- * @import {VisitorResult} from 'unist-util-visit-parents'
+ * @import {
+ *   InclusiveDescendant,
+ *   Matches,
+ *   Visitors as ParentsVisitors,
+ *   VisitorResult,
+ *   VisitorResultExit
+ * } from 'unist-util-visit-parents'
  */
 
 
@@ -20131,10 +20258,13 @@ function toResult(value) {
  * Visit nodes.
  *
  * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+ * (**NLR**) or if `reverse` is given,
+ * in *reverse preorder* (**NRL**).
+ * An `exit` visitor is called in *postorder* (**LRN**)
+ * or if `reverse` is given, in *reverse postorder* (**RLN**).
  *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
+ * You can choose which nodes are visited by passing a `test`.
+ * For complex tests, you should test yourself in a visitor, as it will be
  * faster and will have improved type information.
  *
  * Walking the tree is an intensive task.
@@ -20143,29 +20273,48 @@ function toResult(value) {
  * to check if a node matches, and then perform different operations.
  *
  * You can change the tree.
- * See `Visitor` for more info.
+ * Changes inside a node made when entering it are walked,
+ * changes made when exiting it are not.
+ * See `Visitor` and `VisitorExit` for more info.
  *
  * @overload
  * @param {Tree} tree
+ *   Tree to traverse.
  * @param {Check} check
- * @param {BuildVisitor<Tree, Check>} visitor
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitor<Tree, Check> | BuildVisitors<Tree, Check>} visitors
+ *   Handle each node when entering it,
+ *   or `{enter, exit}` to also handle it when exiting it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @overload
  * @param {Tree} tree
- * @param {BuildVisitor<Tree>} visitor
+ *   Tree to traverse.
+ * @param {BuildVisitor<Tree> | BuildVisitors<Tree>} visitors
+ *   Handle each node when entering it,
+ *   or `{enter, exit}` to also handle it when exiting it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @param {UnistNode} tree
  *   Tree to traverse.
- * @param {Visitor | Test} testOrVisitor
- *   `unist-util-is`-compatible test (optional, omit to pass a visitor).
- * @param {Visitor | boolean | null | undefined} [visitorOrReverse]
- *   Handle each node (when test is omitted, pass `reverse`).
- * @param {boolean | null | undefined} [maybeReverse=false]
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+ * @param {Visitor | Visitors | Test} testOrEnterOrVisitors
+ *   `unist-util-is`-compatible test, `enter`, or `visitors`.
+ * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]
+ *   `enter`, `visitors`, or `reverse` after a test.
+ * @param {boolean | null | undefined} [maybeReverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
  *   Nothing.
  *
@@ -20174,39 +20323,90 @@ function toResult(value) {
  * @template {Test} Check
  *   `unist-util-is`-compatible test.
  */
-function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+function visit(
+  tree,
+  testOrEnterOrVisitors,
+  enterOrVisitorsOrReverse,
+  maybeReverse
+) {
+  /** @type {Test} */
+  let check;
+  /** @type {Visitor | Visitors} */
+  let visitors;
   /** @type {boolean | null | undefined} */
   let reverse;
-  /** @type {Test} */
-  let test;
-  /** @type {Visitor} */
-  let visitor;
 
+  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.
   if (
-    typeof testOrVisitor === 'function' &&
-    typeof visitorOrReverse !== 'function'
+    typeof enterOrVisitorsOrReverse === 'function' ||
+    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')
   ) {
-    test = undefined;
-    visitor = testOrVisitor;
-    reverse = visitorOrReverse;
-  } else {
-    // @ts-expect-error: assume the overload with test was given.
-    test = testOrVisitor;
-    // @ts-expect-error: assume the overload with test was given.
-    visitor = visitorOrReverse;
+    check = /** @type {Test} */ (testOrEnterOrVisitors);
+    visitors = enterOrVisitorsOrReverse;
     reverse = maybeReverse;
   }
+  // Assume no test.
+  else {
+    visitors = /** @type {Visitor | Visitors} */ (testOrEnterOrVisitors);
+    reverse = enterOrVisitorsOrReverse;
+  }
 
-  visitParents(tree, test, overload, reverse);
+  if (typeof visitors === 'function') {
+    visitParents(tree, check, wrap(visitors), reverse);
+  } else {
+    visitParents(tree, check, wrapVisitors(visitors), reverse);
+  }
+}
+
+/**
+ * Turn `visit` visitors into `visitParents` visitors.
+ *
+ * @param {Visitors} visitors
+ *   Visitors for `visit`.
+ * @returns {ParentsVisitors}
+ *   Visitors for `visitParents`.
+ */
+function wrapVisitors(visitors) {
+  // Pass anything else straight to `visitParents` to get its errors.
+  if (!visitors || typeof visitors !== 'object') return visitors
+
+  return {
+    enter:
+      typeof visitors.enter === 'function'
+        ? wrap(visitors.enter)
+        : visitors.enter,
+    exit:
+      typeof visitors.exit === 'function' ? wrap(visitors.exit) : visitors.exit
+  }
+}
+
+/**
+ * Turn a `visit` visitor into a `visitParents` one.
+ *
+ * @template {VisitorResult} Result
+ *   Result type.
+ * @param {(node: UnistNode, index: number | undefined, parent: UnistParent | undefined) => Result} visitor
+ *   Visitor for `visit`.
+ * @returns {(node: UnistNode, parents: Array<UnistParent>, index: number | undefined) => Result}
+ *   Visitor for `visitParents`.
+ */
+function wrap(visitor) {
+  return overload
 
   /**
+   * Call `visitor` with `index` and `parent` instead of `parents`.
+   *
    * @param {UnistNode} node
+   *   Visited node.
    * @param {Array<UnistParent>} parents
+   *   Ancestors of `node`.
+   * @param {number | undefined} index
+   *   Index of `node` in its parent.
+   * @returns {Result}
+   *   What to do next.
    */
-  function overload(node, parents) {
-    const parent = parents[parents.length - 1];
-    const index = parent ? parent.children.indexOf(node) : undefined;
-    return visitor(node, index, parent)
+  function overload(node, parents, index) {
+    return visitor(node, index, parents[parents.length - 1])
   }
 }