@limetech/lime-elements 40.6.0 → 40.6.1

package/dist/types/components/scroller/scroller.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Makes content that is larger than its container scrollable, along one axis.
+ *
+ * The native scrollbar is hidden. Instead, an edge that has more to reveal
+ * fades out, and an arrow appears on it. Clicking the arrow scrolls almost a
+ * page, and leaves the last part of the previous page in view, as a reference
+ * for how far the user has scrolled. For people who have asked their system to
+ * reduce motion, the scroller jumps instead of gliding.
+ *
+ * When something inside the scroller receives focus, the scroller reveals the
+ * item that holds it, together with a glimpse of whatever is next to it. An
+ * item can control how much of its neighbors gets revealed, by setting its
+ * `scroll-margin`. An item that becomes selected without receiving focus is up
+ * to the consumer to reveal, using the `reveal()` method.
+ *
+ * :::note Accessibility
+ * The arrows are only a shortcut for people who use a mouse or a touch screen.
+ * They are not real buttons. Screen readers do not announce them, and the Tab
+ * key skips them. Therefore, the content must contain something that can
+ * receive focus, such as a button, a link or a tab. Without it, there is no way
+ * to scroll with a keyboard. The examples explain the reasoning.
+ * :::
+ *
+ * @slot - The content to scroll. Each child is treated as an item.
+ * @exampleComponent limel-example-scroller-horizontal
+ * @exampleComponent limel-example-scroller-vertical
+ * @private
+ */
+export declare class Scroller {
+    /**
+     * The axis along which the content scrolls.
+     */
+    orientation: 'horizontal' | 'vertical';
+    private canScrollToStart;
+    private canScrollToEnd;
+    private scrollArea?;
+    private scrollContent?;
+    private slotElement?;
+    private readonly fades;
+    private resizeObserver?;
+    private pendingReveal?;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    render(): any;
+    private renderEdge;
+    private observeSize;
+    private readonly handleResize;
+    private readonly updateScrollability;
+    private scrollOnePage;
+    private findItem;
+    private readonly revealFocusedItem;
+    /**
+     * Scrolls an item into view, together with a glimpse of its neighbors.
+     * Whatever receives focus is revealed without being asked to. This is for
+     * an item that becomes selected without receiving focus. If the scroller
+     * is hidden, in a dialog that is closed for instance, the item is revealed
+     * when the scroller is shown.
+     *
+     * @param item - one of the items of the scroller, or something inside one
+     * @param behavior - `auto` jumps to the item, and `smooth` glides there.
+     * Defaults to `smooth`, unless the user has asked to reduce motion.
+     */
+    reveal(item: HTMLElement, behavior?: ScrollBehavior): Promise<void>;
+    private revealItem;
+}
+//# sourceMappingURL=scroller.d.ts.map

package/dist/types/components/tab-bar/tab-bar.d.ts

@@ -7,6 +7,7 @@ import { Tab } from './tab.types';
  * :::
  * An exception for using tab bars in a high level of hierarchy is their usage in modals. This is because modals are perceived as a separate place and not a part of the current context. Therefore you can use tab bars in a modal to group and organize its content.
  * A tab bar can contain an unlimited number of tabs. However, depending on the device width and width of the tabs, the number of tabs that are visible at the same time will vary. When there is limited horizontal space, the component shows a left-arrow and/or right-arrow button, which scrolls and reveals the additional tabs. The tab bar can also be swiped left and right on a touch-device.
+ * The arrows are only a shortcut for people who use a mouse or a touch screen. Screen readers do not announce them, and the Tab key skips them. People who use a keyboard or a screen reader move between the tabs, and the tab bar keeps the selected tab in view.
  * :::tip Other things to consider
  * Never divide the content of a tab using a nested tab bar.
  * Never place two tab bars within the same screen.
@@ -29,34 +30,30 @@ export declare class TabBar {
      */
     private changeTab;
     private host;
-    private canScrollLeft;
-    private canScrollRight;
     private mdcTabBar;
     private setupMdc;
-    private scrollArea;
-    private scrollContent;
+    private revealedTabId?;
+    private hasLoaded;
     constructor();
-    connectedCallback(): void;
+    connectedCallback(): Promise<void>;
     componentDidLoad(): void;
+    componentDidRender(): Promise<void>;
     componentDidUpdate(): void;
     disconnectedCallback(): void;
     render(): any;
     protected tabsChanged(newTabs?: Tab[], oldTabs?: Tab[]): void;
-    protected handleWindowResize(): void;
     private setup;
     private tearDown;
-    private setupListeners;
-    private handleTabActivated;
-    private sortByInactive;
-    private handleScroll;
-    private handleLeftScrollClick;
-    private handleRightScrollClick;
     /**
-     * Calculates how far to scroll when navigation buttons are clicked.
-     * Returns the visible width minus an overlap percentage to maintain context.
-     * Falls back to the constant value if something goes wrong.
+     * A tab that is activated by the user has focus, and the scroller reveals
+     * what has focus. This is for a tab that becomes active without it.
+     *
+     * @param behavior - `auto` to jump to the tab. Leave it out to let the
+     * scroller glide there.
      */
-    private getScrollDistance;
+    private revealActiveTab;
+    private handleTabActivated;
+    private sortByInactive;
     private renderIcon;
     private renderTab;
     private triggerIconColorWarning;

package/dist/types/components.d.ts

@@ -3422,6 +3422,42 @@ export namespace Components {
          */
         "selectedItem"?: ListItem<string | number>;
     }
+    /**
+     * Makes content that is larger than its container scrollable, along one axis.
+     * The native scrollbar is hidden. Instead, an edge that has more to reveal
+     * fades out, and an arrow appears on it. Clicking the arrow scrolls almost a
+     * page, and leaves the last part of the previous page in view, as a reference
+     * for how far the user has scrolled. For people who have asked their system to
+     * reduce motion, the scroller jumps instead of gliding.
+     * When something inside the scroller receives focus, the scroller reveals the
+     * item that holds it, together with a glimpse of whatever is next to it. An
+     * item can control how much of its neighbors gets revealed, by setting its
+     * `scroll-margin`. An item that becomes selected without receiving focus is up
+     * to the consumer to reveal, using the `reveal()` method.
+     * :::note Accessibility
+     * The arrows are only a shortcut for people who use a mouse or a touch screen.
+     * They are not real buttons. Screen readers do not announce them, and the Tab
+     * key skips them. Therefore, the content must contain something that can
+     * receive focus, such as a button, a link or a tab. Without it, there is no way
+     * to scroll with a keyboard. The examples explain the reasoning.
+     * :::
+     * @exampleComponent limel-example-scroller-horizontal
+     * @exampleComponent limel-example-scroller-vertical
+     * @private 
+     */
+    interface LimelScroller {
+        /**
+          * The axis along which the content scrolls.
+          * @default 'horizontal'
+         */
+        "orientation": 'horizontal' | 'vertical';
+        /**
+          * Scrolls an item into view, together with a glimpse of its neighbors. Whatever receives focus is revealed without being asked to. This is for an item that becomes selected without receiving focus. If the scroller is hidden, in a dialog that is closed for instance, the item is revealed when the scroller is shown.
+          * @param item - one of the items of the scroller, or something inside one
+          * @param behavior - `auto` jumps to the item, and `smooth` glides there. Defaults to `smooth`, unless the user has asked to reduce motion.
+         */
+        "reveal": (item: HTMLElement, behavior?: ScrollBehavior) => Promise<void>;
+    }
     /**
      * ## Keyboard
      * Typing characters jumps to the option whose text starts with them, the way
@@ -3788,6 +3824,7 @@ export namespace Components {
      * :::
      * An exception for using tab bars in a high level of hierarchy is their usage in modals. This is because modals are perceived as a separate place and not a part of the current context. Therefore you can use tab bars in a modal to group and organize its content.
      * A tab bar can contain an unlimited number of tabs. However, depending on the device width and width of the tabs, the number of tabs that are visible at the same time will vary. When there is limited horizontal space, the component shows a left-arrow and/or right-arrow button, which scrolls and reveals the additional tabs. The tab bar can also be swiped left and right on a touch-device.
+     * The arrows are only a shortcut for people who use a mouse or a touch screen. Screen readers do not announce them, and the Tab key skips them. People who use a keyboard or a screen reader move between the tabs, and the tab bar keeps the selected tab in view.
      * :::tip Other things to consider
      * Never divide the content of a tab using a nested tab bar.
      * Never place two tab bars within the same screen.
@@ -6322,6 +6359,35 @@ declare global {
         prototype: HTMLLimelRadioButtonGroupElement;
         new (): HTMLLimelRadioButtonGroupElement;
     };
+    /**
+     * Makes content that is larger than its container scrollable, along one axis.
+     * The native scrollbar is hidden. Instead, an edge that has more to reveal
+     * fades out, and an arrow appears on it. Clicking the arrow scrolls almost a
+     * page, and leaves the last part of the previous page in view, as a reference
+     * for how far the user has scrolled. For people who have asked their system to
+     * reduce motion, the scroller jumps instead of gliding.
+     * When something inside the scroller receives focus, the scroller reveals the
+     * item that holds it, together with a glimpse of whatever is next to it. An
+     * item can control how much of its neighbors gets revealed, by setting its
+     * `scroll-margin`. An item that becomes selected without receiving focus is up
+     * to the consumer to reveal, using the `reveal()` method.
+     * :::note Accessibility
+     * The arrows are only a shortcut for people who use a mouse or a touch screen.
+     * They are not real buttons. Screen readers do not announce them, and the Tab
+     * key skips them. Therefore, the content must contain something that can
+     * receive focus, such as a button, a link or a tab. Without it, there is no way
+     * to scroll with a keyboard. The examples explain the reasoning.
+     * :::
+     * @exampleComponent limel-example-scroller-horizontal
+     * @exampleComponent limel-example-scroller-vertical
+     * @private 
+     */
+    interface HTMLLimelScrollerElement extends Components.LimelScroller, HTMLStencilElement {
+    }
+    var HTMLLimelScrollerElement: {
+        prototype: HTMLLimelScrollerElement;
+        new (): HTMLLimelScrollerElement;
+    };
     interface HTMLLimelSelectElementEventMap {
         "change": Option | Option[];
     }
@@ -6533,6 +6599,7 @@ declare global {
      * :::
      * An exception for using tab bars in a high level of hierarchy is their usage in modals. This is because modals are perceived as a separate place and not a part of the current context. Therefore you can use tab bars in a modal to group and organize its content.
      * A tab bar can contain an unlimited number of tabs. However, depending on the device width and width of the tabs, the number of tabs that are visible at the same time will vary. When there is limited horizontal space, the component shows a left-arrow and/or right-arrow button, which scrolls and reveals the additional tabs. The tab bar can also be swiped left and right on a touch-device.
+     * The arrows are only a shortcut for people who use a mouse or a touch screen. Screen readers do not announce them, and the Tab key skips them. People who use a keyboard or a screen reader move between the tabs, and the tab bar keeps the selected tab in view.
      * :::tip Other things to consider
      * Never divide the content of a tab using a nested tab bar.
      * Never place two tab bars within the same screen.
@@ -6820,6 +6887,7 @@ declare global {
         "limel-prosemirror-adapter": HTMLLimelProsemirrorAdapterElement;
         "limel-radio-button": HTMLLimelRadioButtonElement;
         "limel-radio-button-group": HTMLLimelRadioButtonGroupElement;
+        "limel-scroller": HTMLLimelScrollerElement;
         "limel-select": HTMLLimelSelectElement;
         "limel-shortcut": HTMLLimelShortcutElement;
         "limel-slider": HTMLLimelSliderElement;
@@ -10372,6 +10440,36 @@ declare namespace LocalJSX {
          */
         "selectedItem"?: ListItem<string | number>;
     }
+    /**
+     * Makes content that is larger than its container scrollable, along one axis.
+     * The native scrollbar is hidden. Instead, an edge that has more to reveal
+     * fades out, and an arrow appears on it. Clicking the arrow scrolls almost a
+     * page, and leaves the last part of the previous page in view, as a reference
+     * for how far the user has scrolled. For people who have asked their system to
+     * reduce motion, the scroller jumps instead of gliding.
+     * When something inside the scroller receives focus, the scroller reveals the
+     * item that holds it, together with a glimpse of whatever is next to it. An
+     * item can control how much of its neighbors gets revealed, by setting its
+     * `scroll-margin`. An item that becomes selected without receiving focus is up
+     * to the consumer to reveal, using the `reveal()` method.
+     * :::note Accessibility
+     * The arrows are only a shortcut for people who use a mouse or a touch screen.
+     * They are not real buttons. Screen readers do not announce them, and the Tab
+     * key skips them. Therefore, the content must contain something that can
+     * receive focus, such as a button, a link or a tab. Without it, there is no way
+     * to scroll with a keyboard. The examples explain the reasoning.
+     * :::
+     * @exampleComponent limel-example-scroller-horizontal
+     * @exampleComponent limel-example-scroller-vertical
+     * @private 
+     */
+    interface LimelScroller {
+        /**
+          * The axis along which the content scrolls.
+          * @default 'horizontal'
+         */
+        "orientation"?: 'horizontal' | 'vertical';
+    }
     /**
      * ## Keyboard
      * Typing characters jumps to the option whose text starts with them, the way
@@ -10757,6 +10855,7 @@ declare namespace LocalJSX {
      * :::
      * An exception for using tab bars in a high level of hierarchy is their usage in modals. This is because modals are perceived as a separate place and not a part of the current context. Therefore you can use tab bars in a modal to group and organize its content.
      * A tab bar can contain an unlimited number of tabs. However, depending on the device width and width of the tabs, the number of tabs that are visible at the same time will vary. When there is limited horizontal space, the component shows a left-arrow and/or right-arrow button, which scrolls and reveals the additional tabs. The tab bar can also be swiped left and right on a touch-device.
+     * The arrows are only a shortcut for people who use a mouse or a touch screen. Screen readers do not announce them, and the Tab key skips them. People who use a keyboard or a screen reader move between the tabs, and the tab bar keeps the selected tab in view.
      * :::tip Other things to consider
      * Never divide the content of a tab using a nested tab bar.
      * Never place two tab bars within the same screen.
@@ -11710,6 +11809,9 @@ declare namespace LocalJSX {
         "badgeIcons": boolean;
         "maxLinesSecondaryText": number;
     }
+    interface LimelScrollerAttributes {
+        "orientation": 'horizontal' | 'vertical';
+    }
     interface LimelSelectAttributes {
         "disabled": boolean;
         "readonly": boolean;
@@ -11888,6 +11990,7 @@ declare namespace LocalJSX {
         "limel-prosemirror-adapter": Omit<LimelProsemirrorAdapter, keyof LimelProsemirrorAdapterAttributes> & { [K in keyof LimelProsemirrorAdapter & keyof LimelProsemirrorAdapterAttributes]?: LimelProsemirrorAdapter[K] } & { [K in keyof LimelProsemirrorAdapter & keyof LimelProsemirrorAdapterAttributes as `attr:${K}`]?: LimelProsemirrorAdapterAttributes[K] } & { [K in keyof LimelProsemirrorAdapter & keyof LimelProsemirrorAdapterAttributes as `prop:${K}`]?: LimelProsemirrorAdapter[K] };
         "limel-radio-button": Omit<LimelRadioButton, keyof LimelRadioButtonAttributes> & { [K in keyof LimelRadioButton & keyof LimelRadioButtonAttributes]?: LimelRadioButton[K] } & { [K in keyof LimelRadioButton & keyof LimelRadioButtonAttributes as `attr:${K}`]?: LimelRadioButtonAttributes[K] } & { [K in keyof LimelRadioButton & keyof LimelRadioButtonAttributes as `prop:${K}`]?: LimelRadioButton[K] } & OneOf<"id", LimelRadioButton["id"], LimelRadioButtonAttributes["id"]>;
         "limel-radio-button-group": Omit<LimelRadioButtonGroup, keyof LimelRadioButtonGroupAttributes> & { [K in keyof LimelRadioButtonGroup & keyof LimelRadioButtonGroupAttributes]?: LimelRadioButtonGroup[K] } & { [K in keyof LimelRadioButtonGroup & keyof LimelRadioButtonGroupAttributes as `attr:${K}`]?: LimelRadioButtonGroupAttributes[K] } & { [K in keyof LimelRadioButtonGroup & keyof LimelRadioButtonGroupAttributes as `prop:${K}`]?: LimelRadioButtonGroup[K] };
+        "limel-scroller": Omit<LimelScroller, keyof LimelScrollerAttributes> & { [K in keyof LimelScroller & keyof LimelScrollerAttributes]?: LimelScroller[K] } & { [K in keyof LimelScroller & keyof LimelScrollerAttributes as `attr:${K}`]?: LimelScrollerAttributes[K] } & { [K in keyof LimelScroller & keyof LimelScrollerAttributes as `prop:${K}`]?: LimelScroller[K] };
         "limel-select": Omit<LimelSelect, keyof LimelSelectAttributes> & { [K in keyof LimelSelect & keyof LimelSelectAttributes]?: LimelSelect[K] } & { [K in keyof LimelSelect & keyof LimelSelectAttributes as `attr:${K}`]?: LimelSelectAttributes[K] } & { [K in keyof LimelSelect & keyof LimelSelectAttributes as `prop:${K}`]?: LimelSelect[K] };
         "limel-shortcut": Omit<LimelShortcut, keyof LimelShortcutAttributes> & { [K in keyof LimelShortcut & keyof LimelShortcutAttributes]?: LimelShortcut[K] } & { [K in keyof LimelShortcut & keyof LimelShortcutAttributes as `attr:${K}`]?: LimelShortcutAttributes[K] } & { [K in keyof LimelShortcut & keyof LimelShortcutAttributes as `prop:${K}`]?: LimelShortcut[K] };
         "limel-slider": Omit<LimelSlider, keyof LimelSliderAttributes> & { [K in keyof LimelSlider & keyof LimelSliderAttributes]?: LimelSlider[K] } & { [K in keyof LimelSlider & keyof LimelSliderAttributes as `attr:${K}`]?: LimelSliderAttributes[K] } & { [K in keyof LimelSlider & keyof LimelSliderAttributes as `prop:${K}`]?: LimelSlider[K] };
@@ -13085,6 +13188,30 @@ declare module "@stencil/core" {
              * @beta 
              */
             "limel-radio-button-group": LocalJSX.IntrinsicElements["limel-radio-button-group"] & JSXBase.HTMLAttributes<HTMLLimelRadioButtonGroupElement>;
+            /**
+             * Makes content that is larger than its container scrollable, along one axis.
+             * The native scrollbar is hidden. Instead, an edge that has more to reveal
+             * fades out, and an arrow appears on it. Clicking the arrow scrolls almost a
+             * page, and leaves the last part of the previous page in view, as a reference
+             * for how far the user has scrolled. For people who have asked their system to
+             * reduce motion, the scroller jumps instead of gliding.
+             * When something inside the scroller receives focus, the scroller reveals the
+             * item that holds it, together with a glimpse of whatever is next to it. An
+             * item can control how much of its neighbors gets revealed, by setting its
+             * `scroll-margin`. An item that becomes selected without receiving focus is up
+             * to the consumer to reveal, using the `reveal()` method.
+             * :::note Accessibility
+             * The arrows are only a shortcut for people who use a mouse or a touch screen.
+             * They are not real buttons. Screen readers do not announce them, and the Tab
+             * key skips them. Therefore, the content must contain something that can
+             * receive focus, such as a button, a link or a tab. Without it, there is no way
+             * to scroll with a keyboard. The examples explain the reasoning.
+             * :::
+             * @exampleComponent limel-example-scroller-horizontal
+             * @exampleComponent limel-example-scroller-vertical
+             * @private 
+             */
+            "limel-scroller": LocalJSX.IntrinsicElements["limel-scroller"] & JSXBase.HTMLAttributes<HTMLLimelScrollerElement>;
             /**
              * ## Keyboard
              * Typing characters jumps to the option whose text starts with them, the way
@@ -13202,6 +13329,7 @@ declare module "@stencil/core" {
              * :::
              * An exception for using tab bars in a high level of hierarchy is their usage in modals. This is because modals are perceived as a separate place and not a part of the current context. Therefore you can use tab bars in a modal to group and organize its content.
              * A tab bar can contain an unlimited number of tabs. However, depending on the device width and width of the tabs, the number of tabs that are visible at the same time will vary. When there is limited horizontal space, the component shows a left-arrow and/or right-arrow button, which scrolls and reveals the additional tabs. The tab bar can also be swiped left and right on a touch-device.
+             * The arrows are only a shortcut for people who use a mouse or a touch screen. Screen readers do not announce them, and the Tab key skips them. People who use a keyboard or a screen reader move between the tabs, and the tab bar keeps the selected tab in view.
              * :::tip Other things to consider
              * Never divide the content of a tab using a nested tab bar.
              * Never place two tab bars within the same screen.

package/dist/types/global/icon-cache/factory.d.ts

@@ -1,5 +1,5 @@
 import { CacheStorageIconCache } from './cache-storage-icon-cache';
 import { InMemoryIconCache } from './in-memory-icon-cache';
-declare const _default: CacheStorageIconCache | InMemoryIconCache;
-export default _default;
+declare const iconCache: CacheStorageIconCache | InMemoryIconCache;
+export default iconCache;
 //# sourceMappingURL=factory.d.ts.map

package/dist/types/global/translations.d.ts

@@ -2,6 +2,6 @@ export declare class Translations {
     get(key: string, language?: string, params?: object): string;
     private getTranslationsFor;
 }
-declare const _default: Translations;
-export default _default;
+declare const translations: Translations;
+export default translations;
 //# sourceMappingURL=translations.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/lime-elements",
-  "version": "40.6.0",
+  "version": "40.6.1",
   "description": "Lime Elements",
   "author": "Lime Technologies",
   "license": "Apache-2.0",
@@ -52,15 +52,15 @@
     "generate": "stencil generate"
   },
   "devDependencies": {
+    "@commitlint/cli": "^21.2.3",
     "@commitlint/config-conventional": "^21.2.3",
-    "@limetech/eslint-config": "^4.1.0",
-    "@microsoft/api-extractor": "^7.59.2",
-    "@playwright/test": "1.62.1",
+    "@limetech/eslint-config": "^5.0.1",
+    "@microsoft/api-extractor": "^7.59.3",
+    "@playwright/test": "1.63.0",
     "@popperjs/core": "^2.11.8",
     "@rjsf/core": "^6.11.0",
     "@rjsf/utils": "^6.11.0",
     "@rjsf/validator-ajv8": "^6.11.0",
-    "@rollup/plugin-node-resolve": "^13.3.0",
     "@stencil/core": "^4.43.5",
     "@stencil/sass": "^3.3.3",
     "@stencil/vitest": "^1.15.1",
@@ -76,10 +76,10 @@
     "cross-env": "^10.1.0",
     "dayjs": "^1.11.23",
     "diff": "^9.0.0",
-    "eslint": "^9.39.4",
+    "eslint": "^10.11.0",
     "flatpickr": "^4.6.13",
     "glob": "^13.0.6",
-    "globals": "^17.12.0",
+    "globals": "^17.13.0",
     "hast-util-from-dom": "^5.0.1",
     "hast-util-to-mdast": "^10.1.2",
     "html-escaper": "^3.0.3",
@@ -89,12 +89,12 @@
     "lodash-es": "^4.17.23",
     "material-components-web": "^13.0.0",
     "mdast-util-to-markdown": "^2.1.3",
-    "moment": "^2.30.1",
+    "moment": "^2.31.0",
     "morphdom": "^2.7.8",
     "number-abbreviate": "^2.0.0",
     "parse-css-color": "^0.2.1",
-    "postal-mime": "^3.0.1",
-    "prettier": "^3.8.3",
+    "postal-mime": "^4.0.2",
+    "prettier": "^3.9.9",
     "prosemirror-example-setup": "^1.2.3",
     "prosemirror-markdown": "^1.13.8",
     "prosemirror-model": ">=1.25.12",
@@ -119,11 +119,11 @@
     "sirv": "^3.0.2",
     "sortablejs": "^1.15.7",
     "style-to-object": "^2.0.2",
-    "tabulator-tables": "^6.5.3",
+    "tabulator-tables": "^6.6.1",
     "typescript": "^4.9.5",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
-    "yargs": "^17.7.2"
+    "yargs": "^18.2.0"
   },
   "overrides": {
     "prosemirror-model": "$prosemirror-model"