@doist/reactist 28.7.2 → 28.7.3

package/lib/components/key-capturer/key-capturer.d.ts

@@ -1,40 +1,40 @@
-import * as React from 'react';
-type Key = 'ArrowUp' | 'ArrowRight' | 'ArrowDown' | 'ArrowLeft' | 'Enter' | 'Backspace' | 'Escape';
-declare const SUPPORTED_KEYS: Record<string, Key>;
-declare const KeyCapturerResolver: {
-    resolveByKey(eventKey: string): Key | null;
-    resolveByKeyCode(keyCode: number): Key | null;
-};
-type EventHandler = (event: React.SyntheticEvent) => void;
-type EventHandlerProps = {
-    onArrowUp?: EventHandler;
-    onArrowDown?: EventHandler;
-    onArrowLeft?: EventHandler;
-    onArrowRight?: EventHandler;
-    onEnter?: EventHandler;
-    onBackspace?: EventHandler;
-    onEscape?: EventHandler;
-};
-type PropagateProps = {
-    propagateArrowUp?: boolean;
-    propagateArrowDown?: boolean;
-    propagateArrowLeft?: boolean;
-    propagateArrowRight?: boolean;
-    propagateEnter?: boolean;
-    propagateBackspace?: boolean;
-    propagateEscape?: boolean;
-};
-type KeyCapturerProps = EventHandlerProps & PropagateProps & {
-    eventName?: 'onKeyDown' | 'onKeyDownCapture' | 'onKeyUp' | 'onKeyUpCapture';
-    children: React.ReactElement<unknown>;
-};
-/**
- * Use this component to wrap anything you want to handle key events for (e.g. an input).
- * You can specify the `eventName` to capture (defaults to `onKeyDown`).
- * Check the SUPPORTED_KEYS map to see which keys are supported and supply the respective
- * `on${Key}` prop (i.e. `onEnter` or `onArrowDown`).
- * If you want the default behaviour to be preserved (i.e. only want to hook into the event
- * instead of replacing it) set the `propagate${Key}` prop (e.g. propagateBackspace).
- */
-declare function KeyCapturer(props: KeyCapturerProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
-export { KeyCapturer, KeyCapturerResolver, SUPPORTED_KEYS };
+import * as React from 'react';
+type Key = 'ArrowUp' | 'ArrowRight' | 'ArrowDown' | 'ArrowLeft' | 'Enter' | 'Backspace' | 'Escape';
+declare const SUPPORTED_KEYS: Record<string, Key>;
+declare const KeyCapturerResolver: {
+    resolveByKey(eventKey: string): Key | null;
+    resolveByKeyCode(keyCode: number): Key | null;
+};
+type EventHandler = (event: React.SyntheticEvent) => void;
+type EventHandlerProps = {
+    onArrowUp?: EventHandler;
+    onArrowDown?: EventHandler;
+    onArrowLeft?: EventHandler;
+    onArrowRight?: EventHandler;
+    onEnter?: EventHandler;
+    onBackspace?: EventHandler;
+    onEscape?: EventHandler;
+};
+type PropagateProps = {
+    propagateArrowUp?: boolean;
+    propagateArrowDown?: boolean;
+    propagateArrowLeft?: boolean;
+    propagateArrowRight?: boolean;
+    propagateEnter?: boolean;
+    propagateBackspace?: boolean;
+    propagateEscape?: boolean;
+};
+type KeyCapturerProps = EventHandlerProps & PropagateProps & {
+    eventName?: 'onKeyDown' | 'onKeyDownCapture' | 'onKeyUp' | 'onKeyUpCapture';
+    children: React.ReactElement<unknown>;
+};
+/**
+ * Use this component to wrap anything you want to handle key events for (e.g. an input).
+ * You can specify the `eventName` to capture (defaults to `onKeyDown`).
+ * Check the SUPPORTED_KEYS map to see which keys are supported and supply the respective
+ * `on${Key}` prop (i.e. `onEnter` or `onArrowDown`).
+ * If you want the default behaviour to be preserved (i.e. only want to hook into the event
+ * instead of replacing it) set the `propagate${Key}` prop (e.g. propagateBackspace).
+ */
+declare function KeyCapturer(props: KeyCapturerProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export { KeyCapturer, KeyCapturerResolver, SUPPORTED_KEYS };

package/lib/components/key-capturer/key-capturer.js

@@ -1,2 +1,172 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var r=require("../../_virtual/_rollupPluginBabelHelpers.js");function e(r){if(r&&r.__esModule)return r;var e=Object.create(null);return r&&Object.keys(r).forEach((function(t){if("default"!==t){var o=Object.getOwnPropertyDescriptor(r,t);Object.defineProperty(e,t,o.get?o:{enumerable:!0,get:function(){return r[t]}})}})),e.default=r,e}var t=e(require("react"));const o={resolveByKey(r){switch(r){case"Left":case"ArrowLeft":return"ArrowLeft";case"Up":case"ArrowUp":return"ArrowUp";case"Right":case"ArrowRight":return"ArrowRight";case"Down":case"ArrowDown":return"ArrowDown";case"Enter":return"Enter";case"Backspace":return"Backspace";case"Esc":case"Escape":return"Escape";default:return null}},resolveByKeyCode(r){switch(r){case 37:return"ArrowLeft";case 38:return"ArrowUp";case 39:return"ArrowRight";case 40:return"ArrowDown";case 13:return"Enter";case 8:return"Backspace";case 27:return"Escape";default:return null}}},n={ArrowUp:"onArrowUp",ArrowDown:"onArrowDown",ArrowLeft:"onArrowLeft",ArrowRight:"onArrowRight",Enter:"onEnter",Backspace:"onBackspace",Escape:"onEscape"},a={ArrowUp:"propagateArrowUp",ArrowDown:"propagateArrowDown",ArrowLeft:"propagateArrowLeft",ArrowRight:"propagateArrowRight",Enter:"propagateEnter",Backspace:"propagateBackspace",Escape:"propagateEscape"};exports.KeyCapturer=function(e){const{children:c,eventName:s="onKeyDown"}=e,p=t.useRef(!1);return t.cloneElement(c,r.objectSpread2({[s]:function(r){const t=void 0!==r.key?o.resolveByKey(r.key):o.resolveByKeyCode(r.keyCode);if(!t)return;const c=e[a[t]]||!1,s=e[n[t]];"Enter"===t&&s&&(p.current||229===(r.keyCode||r.which))||s&&(s(r),c||(r.preventDefault(),r.stopPropagation()))}},e.onEnter?{onCompositionStart:()=>{p.current=!0},onCompositionEnd:()=>{p.current=!1}}:void 0))},exports.KeyCapturerResolver=o,exports.SUPPORTED_KEYS={ARROW_UP:"ArrowUp",ARROW_RIGHT:"ArrowRight",ARROW_DOWN:"ArrowDown",ARROW_LEFT:"ArrowLeft",ENTER:"Enter",BACKSPACE:"Backspace",ESCAPE:"Escape"};
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var SUPPORTED_KEYS = {
+    ARROW_UP: 'ArrowUp',
+    ARROW_RIGHT: 'ArrowRight',
+    ARROW_DOWN: 'ArrowDown',
+    ARROW_LEFT: 'ArrowLeft',
+    ENTER: 'Enter',
+    BACKSPACE: 'Backspace',
+    ESCAPE: 'Escape'
+};
+var KeyCapturerResolver = {
+    resolveByKey: function (eventKey) {
+        switch (eventKey) {
+            case 'Left': // IE specific
+            case 'ArrowLeft': {
+                return 'ArrowLeft';
+            }
+            case 'Up': // IE specific
+            case 'ArrowUp': {
+                return 'ArrowUp';
+            }
+            case 'Right': // IE specific
+            case 'ArrowRight': {
+                return 'ArrowRight';
+            }
+            case 'Down': // IE specific
+            case 'ArrowDown': {
+                return 'ArrowDown';
+            }
+            case 'Enter': {
+                return 'Enter';
+            }
+            case 'Backspace': {
+                return 'Backspace';
+            }
+            case 'Esc': // IE specific
+            case 'Escape': {
+                return 'Escape';
+            }
+            default: {
+                return null;
+            }
+        }
+    },
+    resolveByKeyCode: function (keyCode) {
+        switch (keyCode) {
+            case 37: {
+                return 'ArrowLeft';
+            }
+            case 38: {
+                return 'ArrowUp';
+            }
+            case 39: {
+                return 'ArrowRight';
+            }
+            case 40: {
+                return 'ArrowDown';
+            }
+            case 13: {
+                return 'Enter';
+            }
+            case 8: {
+                return 'Backspace';
+            }
+            case 27: {
+                return 'Escape';
+            }
+            default: {
+                return null;
+            }
+        }
+    }
+};
+var keyEventHandlerMapping = {
+    ArrowUp: 'onArrowUp',
+    ArrowDown: 'onArrowDown',
+    ArrowLeft: 'onArrowLeft',
+    ArrowRight: 'onArrowRight',
+    Enter: 'onEnter',
+    Backspace: 'onBackspace',
+    Escape: 'onEscape'
+};
+var keyPropagatePropMapping = {
+    ArrowUp: 'propagateArrowUp',
+    ArrowDown: 'propagateArrowDown',
+    ArrowLeft: 'propagateArrowLeft',
+    ArrowRight: 'propagateArrowRight',
+    Enter: 'propagateEnter',
+    Backspace: 'propagateBackspace',
+    Escape: 'propagateEscape'
+};
+/**
+ * Use this component to wrap anything you want to handle key events for (e.g. an input).
+ * You can specify the `eventName` to capture (defaults to `onKeyDown`).
+ * Check the SUPPORTED_KEYS map to see which keys are supported and supply the respective
+ * `on${Key}` prop (i.e. `onEnter` or `onArrowDown`).
+ * If you want the default behaviour to be preserved (i.e. only want to hook into the event
+ * instead of replacing it) set the `propagate${Key}` prop (e.g. propagateBackspace).
+ */
+function KeyCapturer(props) {
+    var _a;
+    var children = props.children, _b = props.eventName, eventName = _b === void 0 ? 'onKeyDown' : _b;
+    var composingRef = React__namespace.useRef(false);
+    var composingEventHandlers = props.onEnter
+        ? {
+            onCompositionStart: function () {
+                composingRef.current = true;
+            },
+            onCompositionEnd: function () {
+                composingRef.current = false;
+            }
+        }
+        : undefined;
+    function handleKeyEvent(event) {
+        // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode
+        var key = event.key !== undefined
+            ? KeyCapturerResolver.resolveByKey(event.key)
+            : KeyCapturerResolver.resolveByKeyCode(event.keyCode);
+        if (!key)
+            return;
+        var propagateEvent = props[keyPropagatePropMapping[key]] || false;
+        var eventHandler = props[keyEventHandlerMapping[key]];
+        if (key === 'Enter' && eventHandler) {
+            if (composingRef.current ||
+                // Safari fires the onCompositionEnd event before the keydown event, so we
+                // have to rely on the 229 keycode, which is Enter when fired from an IME
+                // https://www.w3.org/TR/uievents/#determine-keydown-keyup-keyCode
+                (event.keyCode || event.which) === 229) {
+                return;
+            }
+        }
+        if (eventHandler) {
+            eventHandler(event);
+            if (!propagateEvent) {
+                event.preventDefault();
+                event.stopPropagation();
+            }
+        }
+    }
+    return React__namespace.cloneElement(children, tslib.__assign((_a = {}, _a[eventName] = handleKeyEvent, _a), composingEventHandlers));
+}
+
+exports.KeyCapturer = KeyCapturer;
+exports.KeyCapturerResolver = KeyCapturerResolver;
+exports.SUPPORTED_KEYS = SUPPORTED_KEYS;
 //# sourceMappingURL=key-capturer.js.map

package/lib/components/key-capturer/key-capturer.js.map

@@ -1 +1 @@
-{"version":3,"file":"key-capturer.js","sources":["../../../src/components/key-capturer/key-capturer.tsx"],"sourcesContent":["import * as React from 'react'\n\ntype Key = 'ArrowUp' | 'ArrowRight' | 'ArrowDown' | 'ArrowLeft' | 'Enter' | 'Backspace' | 'Escape'\n\nconst SUPPORTED_KEYS: Record<string, Key> = {\n    ARROW_UP: 'ArrowUp',\n    ARROW_RIGHT: 'ArrowRight',\n    ARROW_DOWN: 'ArrowDown',\n    ARROW_LEFT: 'ArrowLeft',\n    ENTER: 'Enter',\n    BACKSPACE: 'Backspace',\n    ESCAPE: 'Escape',\n}\n\nconst KeyCapturerResolver = {\n    resolveByKey(eventKey: string): Key | null {\n        switch (eventKey) {\n            case 'Left': // IE specific\n            case 'ArrowLeft': {\n                return 'ArrowLeft'\n            }\n            case 'Up': // IE specific\n            case 'ArrowUp': {\n                return 'ArrowUp'\n            }\n            case 'Right': // IE specific\n            case 'ArrowRight': {\n                return 'ArrowRight'\n            }\n            case 'Down': // IE specific\n            case 'ArrowDown': {\n                return 'ArrowDown'\n            }\n            case 'Enter': {\n                return 'Enter'\n            }\n            case 'Backspace': {\n                return 'Backspace'\n            }\n            case 'Esc': // IE specific\n            case 'Escape': {\n                return 'Escape'\n            }\n            default: {\n                return null\n            }\n        }\n    },\n\n    resolveByKeyCode(keyCode: number): Key | null {\n        switch (keyCode) {\n            case 37: {\n                return 'ArrowLeft'\n            }\n            case 38: {\n                return 'ArrowUp'\n            }\n            case 39: {\n                return 'ArrowRight'\n            }\n            case 40: {\n                return 'ArrowDown'\n            }\n            case 13: {\n                return 'Enter'\n            }\n            case 8: {\n                return 'Backspace'\n            }\n            case 27: {\n                return 'Escape'\n            }\n            default: {\n                return null\n            }\n        }\n    },\n}\n\ntype EventHandler = (event: React.SyntheticEvent) => void\n\ntype EventHandlerProps = {\n    onArrowUp?: EventHandler\n    onArrowDown?: EventHandler\n    onArrowLeft?: EventHandler\n    onArrowRight?: EventHandler\n    onEnter?: EventHandler\n    onBackspace?: EventHandler\n    onEscape?: EventHandler\n}\n\ntype PropagateProps = {\n    propagateArrowUp?: boolean\n    propagateArrowDown?: boolean\n    propagateArrowLeft?: boolean\n    propagateArrowRight?: boolean\n    propagateEnter?: boolean\n    propagateBackspace?: boolean\n    propagateEscape?: boolean\n}\n\nconst keyEventHandlerMapping: Record<Key, keyof EventHandlerProps> = {\n    ArrowUp: 'onArrowUp',\n    ArrowDown: 'onArrowDown',\n    ArrowLeft: 'onArrowLeft',\n    ArrowRight: 'onArrowRight',\n    Enter: 'onEnter',\n    Backspace: 'onBackspace',\n    Escape: 'onEscape',\n}\n\nconst keyPropagatePropMapping: Record<Key, keyof PropagateProps> = {\n    ArrowUp: 'propagateArrowUp',\n    ArrowDown: 'propagateArrowDown',\n    ArrowLeft: 'propagateArrowLeft',\n    ArrowRight: 'propagateArrowRight',\n    Enter: 'propagateEnter',\n    Backspace: 'propagateBackspace',\n    Escape: 'propagateEscape',\n}\n\ntype KeyCapturerProps = EventHandlerProps &\n    PropagateProps & {\n        eventName?: 'onKeyDown' | 'onKeyDownCapture' | 'onKeyUp' | 'onKeyUpCapture'\n        children: React.ReactElement<unknown>\n    }\n\n/**\n * Use this component to wrap anything you want to handle key events for (e.g. an input).\n * You can specify the `eventName` to capture (defaults to `onKeyDown`).\n * Check the SUPPORTED_KEYS map to see which keys are supported and supply the respective\n * `on${Key}` prop (i.e. `onEnter` or `onArrowDown`).\n * If you want the default behaviour to be preserved (i.e. only want to hook into the event\n * instead of replacing it) set the `propagate${Key}` prop (e.g. propagateBackspace).\n */\nfunction KeyCapturer(props: KeyCapturerProps) {\n    const { children, eventName = 'onKeyDown' } = props\n    const composingRef = React.useRef(false)\n    const composingEventHandlers = props.onEnter\n        ? {\n              onCompositionStart: () => {\n                  composingRef.current = true\n              },\n              onCompositionEnd: () => {\n                  composingRef.current = false\n              },\n          }\n        : undefined\n\n    function handleKeyEvent(event: React.KeyboardEvent<HTMLInputElement>) {\n        // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode\n        const key =\n            event.key !== undefined\n                ? KeyCapturerResolver.resolveByKey(event.key)\n                : KeyCapturerResolver.resolveByKeyCode(event.keyCode)\n\n        if (!key) return\n        const propagateEvent = props[keyPropagatePropMapping[key]] || false\n        const eventHandler = props[keyEventHandlerMapping[key]]\n\n        if (key === 'Enter' && eventHandler) {\n            if (\n                composingRef.current ||\n                // Safari fires the onCompositionEnd event before the keydown event, so we\n                // have to rely on the 229 keycode, which is Enter when fired from an IME\n                // https://www.w3.org/TR/uievents/#determine-keydown-keyup-keyCode\n                (event.keyCode || event.which) === 229\n            ) {\n                return\n            }\n        }\n\n        if (eventHandler) {\n            eventHandler(event)\n            if (!propagateEvent) {\n                event.preventDefault()\n                event.stopPropagation()\n            }\n        }\n    }\n\n    return React.cloneElement(children, {\n        [eventName]: handleKeyEvent,\n        ...composingEventHandlers,\n    })\n}\n\nexport { KeyCapturer, KeyCapturerResolver, SUPPORTED_KEYS }\n"],"names":["KeyCapturerResolver","resolveByKey","eventKey","resolveByKeyCode","keyCode","keyEventHandlerMapping","ArrowUp","ArrowDown","ArrowLeft","ArrowRight","Enter","Backspace","Escape","keyPropagatePropMapping","props","children","eventName","composingRef","React","useRef","cloneElement","_objectSpread","[object Object]","event","key","undefined","propagateEvent","eventHandler","current","which","preventDefault","stopPropagation","onEnter","onCompositionStart","onCompositionEnd","ARROW_UP","ARROW_RIGHT","ARROW_DOWN","ARROW_LEFT","ENTER","BACKSPACE","ESCAPE"],"mappings":"2aAIA,MAUMA,EAAsB,CACxBC,aAAaC,GACT,OAAQA,GACJ,IAAK,OACL,IAAK,YACD,MAAO,YAEX,IAAK,KACL,IAAK,UACD,MAAO,UAEX,IAAK,QACL,IAAK,aACD,MAAO,aAEX,IAAK,OACL,IAAK,YACD,MAAO,YAEX,IAAK,QACD,MAAO,QAEX,IAAK,YACD,MAAO,YAEX,IAAK,MACL,IAAK,SACD,MAAO,SAEX,QACI,OAAO,OAKnBC,iBAAiBC,GACb,OAAQA,GACJ,KAAK,GACD,MAAO,YAEX,KAAK,GACD,MAAO,UAEX,KAAK,GACD,MAAO,aAEX,KAAK,GACD,MAAO,YAEX,KAAK,GACD,MAAO,QAEX,KAAK,EACD,MAAO,YAEX,KAAK,GACD,MAAO,SAEX,QACI,OAAO,QA4BjBC,EAA+D,CACjEC,QAAS,YACTC,UAAW,cACXC,UAAW,cACXC,WAAY,eACZC,MAAO,UACPC,UAAW,cACXC,OAAQ,YAGNC,EAA6D,CAC/DP,QAAS,mBACTC,UAAW,qBACXC,UAAW,qBACXC,WAAY,sBACZC,MAAO,iBACPC,UAAW,qBACXC,OAAQ,uCAiBZ,SAAqBE,GACjB,MAAMC,SAAEA,EAAFC,UAAYA,EAAY,aAAgBF,EACxCG,EAAeC,EAAMC,QAAO,GA4ClC,OAAOD,EAAME,aAAaL,EAAnBM,gBAAA,CACHC,CAACN,GAjCL,SAAwBO,GAEpB,MAAMC,OACYC,IAAdF,EAAMC,IACAxB,EAAoBC,aAAasB,EAAMC,KACvCxB,EAAoBG,iBAAiBoB,EAAMnB,SAErD,IAAKoB,EAAK,OACV,MAAME,EAAiBZ,EAAMD,EAAwBW,MAAS,EACxDG,EAAeb,EAAMT,EAAuBmB,IAEtC,UAARA,GAAmBG,IAEfV,EAAaW,SAIsB,OAAlCL,EAAMnB,SAAWmB,EAAMM,SAM5BF,IACAA,EAAaJ,GACRG,IACDH,EAAMO,iBACNP,EAAMQ,sBAtCajB,EAAMkB,QAC/B,CACIC,mBAAoB,KAChBhB,EAAaW,SAAU,GAE3BM,iBAAkB,KACdjB,EAAaW,SAAU,SAG/BH,0DA/IkC,CACxCU,SAAU,UACVC,YAAa,aACbC,WAAY,YACZC,WAAY,YACZC,MAAO,QACPC,UAAW,YACXC,OAAQ"}
+{"version":3,"file":"key-capturer.js","sources":["../../../src/components/key-capturer/key-capturer.tsx"],"sourcesContent":[null],"names":["React","__assign"],"mappings":"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"}

package/lib/components/keyboard-shortcut/index.d.ts

@@ -1,2 +1,2 @@
-import { KeyboardShortcut } from './keyboard-shortcut';
-export default KeyboardShortcut;
+import { KeyboardShortcut } from './keyboard-shortcut';
+export default KeyboardShortcut;

package/lib/components/keyboard-shortcut/index.js

@@ -1,2 +1,10 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./keyboard-shortcut.js");exports.default=e.KeyboardShortcut;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var keyboardShortcut = require('./keyboard-shortcut.js');
+
+
+
+exports["default"] = keyboardShortcut.KeyboardShortcut;
 //# sourceMappingURL=index.js.map

package/lib/components/keyboard-shortcut/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/lib/components/keyboard-shortcut/keyboard-shortcut.d.ts

@@ -1,44 +1,44 @@
-import * as React from 'react';
-declare let globalTranslateKey: (key: string) => string;
-type TranslateKey = typeof globalTranslateKey;
-type NativeSpanProps = React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
-type Props = Omit<NativeSpanProps, 'children'> & {
-    /**
-     * The shortcut to be represented as markup. It supports an intuitive syntax where you can
-     * combine modifiers (cmd, ctrl, shift, alt) with single keys all concatenated with plus signs.
-     * You can also pass various shortcuts as an array, which will be depicted separated by commas.
-     */
-    children: string | string[];
-    /**
-     * A function that allows you to change how some key names are represented. This may be useful,
-     * for instance, to translate modifier names that are expressed differently in other languages
-     * (e.g. `Ctrl` is named `Strg` in German).
-     *
-     * It defaults to a global version that leaves the key as is. You can pass your version as a
-     * prop, or you can also set your own version of this global default one, so you don't need to
-     * pass your own on each invocation of this component.
-     *
-     * ```js
-     * import { KeyboardShortcut } from '@doist/reactist'
-     * KeyboardShortcut.setTranslateKey = key => { ... }
-     * ```
-     *
-     * Note: When the component detects the macOS operating system it bypasses key translation for
-     * most modifiers and uses macOS-specific symbols. See the `isMac` prop for details.
-     */
-    translateKey?: TranslateKey;
-    /**
-     * This prop is not meant to be passed. The component will automatically initialize it to `true`
-     * if it detects that the current browser / operating system is on macOS, in which case modifier
-     * keys are represented using macOS' notation (e.g. ⌘ ⌃ ⌥ ⇧).
-     *
-     * Though it is discouraged, if you don't want this special treatment in macOS, you can pass
-     * `isMac={false}` in all invocations of this component.
-     */
-    isMac?: boolean;
-};
-declare function KeyboardShortcut({ children, className, translateKey, isMac, ...props }: Props): React.JSX.Element;
-declare namespace KeyboardShortcut {
-    var setTranslateKey: (tr: (key: string) => string) => void;
-}
-export { KeyboardShortcut };
+import * as React from 'react';
+declare let globalTranslateKey: (key: string) => string;
+type TranslateKey = typeof globalTranslateKey;
+type NativeSpanProps = React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
+type Props = Omit<NativeSpanProps, 'children'> & {
+    /**
+     * The shortcut to be represented as markup. It supports an intuitive syntax where you can
+     * combine modifiers (cmd, ctrl, shift, alt) with single keys all concatenated with plus signs.
+     * You can also pass various shortcuts as an array, which will be depicted separated by commas.
+     */
+    children: string | string[];
+    /**
+     * A function that allows you to change how some key names are represented. This may be useful,
+     * for instance, to translate modifier names that are expressed differently in other languages
+     * (e.g. `Ctrl` is named `Strg` in German).
+     *
+     * It defaults to a global version that leaves the key as is. You can pass your version as a
+     * prop, or you can also set your own version of this global default one, so you don't need to
+     * pass your own on each invocation of this component.
+     *
+     * ```js
+     * import { KeyboardShortcut } from '@doist/reactist'
+     * KeyboardShortcut.setTranslateKey = key => { ... }
+     * ```
+     *
+     * Note: When the component detects the macOS operating system it bypasses key translation for
+     * most modifiers and uses macOS-specific symbols. See the `isMac` prop for details.
+     */
+    translateKey?: TranslateKey;
+    /**
+     * This prop is not meant to be passed. The component will automatically initialize it to `true`
+     * if it detects that the current browser / operating system is on macOS, in which case modifier
+     * keys are represented using macOS' notation (e.g. ⌘ ⌃ ⌥ ⇧).
+     *
+     * Though it is discouraged, if you don't want this special treatment in macOS, you can pass
+     * `isMac={false}` in all invocations of this component.
+     */
+    isMac?: boolean;
+};
+declare function KeyboardShortcut({ children, className, translateKey, isMac, ...props }: Props): React.JSX.Element;
+declare namespace KeyboardShortcut {
+    var setTranslateKey: (tr: (key: string) => string) => void;
+}
+export { KeyboardShortcut };

package/lib/components/keyboard-shortcut/keyboard-shortcut.js

@@ -1,2 +1,98 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../_virtual/_rollupPluginBabelHelpers.js"),t=require("react"),r=require("classnames");function a(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function c(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var a=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,t}var n=c(t),s=a(r);const o=["children","className","translateKey","isMac"];let l=e=>e;function u(e){switch(e.toLowerCase()){case"cmd":case"mod":return"⌘";case"control":case"ctrl":return"⌃";case"alt":return"⌥";case"shift":return"⇧";case"space":return"␣";default:return e}}function i(t){var r;let{children:a,className:c,translateKey:i=l,isMac:d=(null==(r=navigator.platform)?void 0:r.toUpperCase().includes("MAC"))??!1}=t,p=e.objectWithoutProperties(t,o);const f="string"==typeof a?[a]:a;return n.createElement("span",e.objectSpread2({className:s.default("reactist_keyboard_shortcut",c,{"reactist_keyboard_shortcut--macos":d})},p),f.map((e,t)=>n.createElement(n.Fragment,{key:t},0===t?null:", ",n.createElement("kbd",null,function(e,t,r){const a=t?u:r,c=/\b(mod|cmd|ctrl|control|alt|shift)\b/i.test(e);return t||(e=e.replace(/\b(mod|cmd)\b/i,"ctrl")),e.split(/\s*\+\s*/).map((function(e){return function(e){return/^(mod|cmd|ctrl|control|alt|shift|space|super)$/i.test(e)}(e)?function(e){return e.charAt(0).toUpperCase()+e.slice(1).toLowerCase()}(a(e)):c&&1===e.length?e.toUpperCase():e}))}(e,d,i).map((e,t)=>n.createElement("kbd",{key:t},e))))))}i.setTranslateKey=e=>{l=e},exports.KeyboardShortcut=i;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+var classNames = require('classnames');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var classNames__default = /*#__PURE__*/_interopDefaultLegacy(classNames);
+
+//
+// Support for setting up how to translate modifiers globally.
+//
+var globalTranslateKey = function (key) { return key; };
+KeyboardShortcut.setTranslateKey = function (tr) {
+    globalTranslateKey = tr;
+};
+function translateKeyMac(key) {
+    switch (key.toLowerCase()) {
+        case 'cmd':
+        case 'mod':
+            return '⌘';
+        case 'control':
+        case 'ctrl':
+            return '⌃';
+        case 'alt':
+            return '⌥';
+        case 'shift':
+            return '⇧';
+        case 'space':
+            return '␣';
+        default:
+            return key;
+    }
+}
+//
+// Some helpers
+//
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+function hasModifiers(str) {
+    return /\b(mod|cmd|ctrl|control|alt|shift)\b/i.test(str);
+}
+function isSpecialKey(str) {
+    return /^(mod|cmd|ctrl|control|alt|shift|space|super)$/i.test(str);
+}
+function parseKeys(shortcut, isMac, translateKey) {
+    var t = isMac ? translateKeyMac : translateKey;
+    var _hasModifiers = hasModifiers(shortcut);
+    function mapIndividualKey(str) {
+        if (isSpecialKey(str)) {
+            return capitalize(t(str));
+        }
+        if (_hasModifiers && str.length === 1) {
+            return str.toUpperCase();
+        }
+        return str;
+    }
+    if (!isMac) {
+        shortcut = shortcut.replace(/\b(mod|cmd)\b/i, 'ctrl');
+    }
+    return shortcut.split(/\s*\+\s*/).map(mapIndividualKey);
+}
+function KeyboardShortcut(_a) {
+    var _b, _c;
+    var children = _a.children, className = _a.className, _d = _a.translateKey, translateKey = _d === void 0 ? globalTranslateKey : _d, _e = _a.isMac, isMac = _e === void 0 ? (_c = (_b = navigator.platform) === null || _b === void 0 ? void 0 : _b.toUpperCase().includes('MAC')) !== null && _c !== void 0 ? _c : false : _e, props = tslib.__rest(_a, ["children", "className", "translateKey", "isMac"]);
+    var shortcuts = typeof children === 'string' ? [children] : children;
+    return (React__namespace.createElement("span", tslib.__assign({ className: classNames__default["default"]('reactist_keyboard_shortcut', className, {
+            'reactist_keyboard_shortcut--macos': isMac
+        }) }, props), shortcuts.map(function (shortcut, i) { return (React__namespace.createElement(React__namespace.Fragment, { key: i },
+        i === 0 ? null : ', ',
+        React__namespace.createElement("kbd", null, parseKeys(shortcut, isMac, translateKey).map(function (key, j) { return (React__namespace.createElement("kbd", { key: j }, key)); })))); })));
+}
+
+exports.KeyboardShortcut = KeyboardShortcut;
 //# sourceMappingURL=keyboard-shortcut.js.map

package/lib/components/keyboard-shortcut/keyboard-shortcut.js.map

@@ -1 +1 @@
-{"version":3,"file":"keyboard-shortcut.js","sources":["../../../src/components/keyboard-shortcut/keyboard-shortcut.tsx"],"sourcesContent":["import * as React from 'react'\nimport classNames from 'classnames'\n\n//\n// Support for setting up how to translate modifiers globally.\n//\n\nlet globalTranslateKey = (key: string) => key\n\ntype TranslateKey = typeof globalTranslateKey\n\nKeyboardShortcut.setTranslateKey = (tr: TranslateKey) => {\n    globalTranslateKey = tr\n}\n\nfunction translateKeyMac(key: string) {\n    switch (key.toLowerCase()) {\n        case 'cmd':\n        case 'mod':\n            return '⌘'\n        case 'control':\n        case 'ctrl':\n            return '⌃'\n        case 'alt':\n            return '⌥'\n        case 'shift':\n            return '⇧'\n        case 'space':\n            return '␣'\n        default:\n            return key\n    }\n}\n\n//\n// Some helpers\n//\n\nfunction capitalize(str: string) {\n    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()\n}\n\nfunction hasModifiers(str: string) {\n    return /\\b(mod|cmd|ctrl|control|alt|shift)\\b/i.test(str)\n}\n\nfunction isSpecialKey(str: string) {\n    return /^(mod|cmd|ctrl|control|alt|shift|space|super)$/i.test(str)\n}\n\nfunction parseKeys(shortcut: string, isMac: boolean, translateKey: TranslateKey) {\n    const t = isMac ? translateKeyMac : translateKey\n    const _hasModifiers = hasModifiers(shortcut)\n\n    function mapIndividualKey(str: string) {\n        if (isSpecialKey(str)) {\n            return capitalize(t(str))\n        }\n        if (_hasModifiers && str.length === 1) {\n            return str.toUpperCase()\n        }\n        return str\n    }\n\n    if (!isMac) {\n        shortcut = shortcut.replace(/\\b(mod|cmd)\\b/i, 'ctrl')\n    }\n\n    return shortcut.split(/\\s*\\+\\s*/).map(mapIndividualKey)\n}\n\n//\n// The KeyboardShortcut component\n//\n\ntype NativeSpanProps = React.DetailedHTMLProps<\n    React.HTMLAttributes<HTMLSpanElement>,\n    HTMLSpanElement\n>\n\ntype Props = Omit<NativeSpanProps, 'children'> & {\n    /**\n     * The shortcut to be represented as markup. It supports an intuitive syntax where you can\n     * combine modifiers (cmd, ctrl, shift, alt) with single keys all concatenated with plus signs.\n     * You can also pass various shortcuts as an array, which will be depicted separated by commas.\n     */\n    children: string | string[]\n    /**\n     * A function that allows you to change how some key names are represented. This may be useful,\n     * for instance, to translate modifier names that are expressed differently in other languages\n     * (e.g. `Ctrl` is named `Strg` in German).\n     *\n     * It defaults to a global version that leaves the key as is. You can pass your version as a\n     * prop, or you can also set your own version of this global default one, so you don't need to\n     * pass your own on each invocation of this component.\n     *\n     * ```js\n     * import { KeyboardShortcut } from '@doist/reactist'\n     * KeyboardShortcut.setTranslateKey = key => { ... }\n     * ```\n     *\n     * Note: When the component detects the macOS operating system it bypasses key translation for\n     * most modifiers and uses macOS-specific symbols. See the `isMac` prop for details.\n     */\n    translateKey?: TranslateKey\n    /**\n     * This prop is not meant to be passed. The component will automatically initialize it to `true`\n     * if it detects that the current browser / operating system is on macOS, in which case modifier\n     * keys are represented using macOS' notation (e.g. ⌘ ⌃ ⌥ ⇧).\n     *\n     * Though it is discouraged, if you don't want this special treatment in macOS, you can pass\n     * `isMac={false}` in all invocations of this component.\n     */\n    isMac?: boolean\n}\n\nfunction KeyboardShortcut({\n    children,\n    className,\n    translateKey = globalTranslateKey,\n    isMac = navigator.platform?.toUpperCase().includes('MAC') ?? false,\n    ...props\n}: Props) {\n    const shortcuts = typeof children === 'string' ? [children] : children\n    return (\n        <span\n            className={classNames('reactist_keyboard_shortcut', className, {\n                'reactist_keyboard_shortcut--macos': isMac,\n            })}\n            {...props}\n        >\n            {shortcuts.map((shortcut, i) => (\n                <React.Fragment key={i}>\n                    {i === 0 ? null : ', '}\n                    <kbd>\n                        {parseKeys(shortcut, isMac, translateKey).map((key, j) => (\n                            <kbd key={j}>{key}</kbd>\n                        ))}\n                    </kbd>\n                </React.Fragment>\n            ))}\n        </span>\n    )\n}\n\nexport { KeyboardShortcut }\n"],"names":["globalTranslateKey","key","translateKeyMac","toLowerCase","KeyboardShortcut","_ref","_navigator$platform","children","className","translateKey","isMac","toUpperCase","navigator","platform","includes","props","_objectWithoutProperties","objectWithoutProperties","_excluded","shortcuts","React","_objectSpread","classNames","reactist_keyboard_shortcut--macos","map","shortcut","i","createElement","Fragment","t","_hasModifiers","test","replace","split","str","isSpecialKey","charAt","slice","capitalize","length","parseKeys","j","setTranslateKey","tr"],"mappings":"8kBAOA,IAAIA,EAAsBC,GAAgBA,EAQ1C,SAASC,EAAgBD,GACrB,OAAQA,EAAIE,eACR,IAAK,MACL,IAAK,MACD,MAAO,IACX,IAAK,UACL,IAAK,OACD,MAAO,IACX,IAAK,MACD,MAAO,IACX,IAAK,QACD,MAAO,IACX,IAAK,QACD,MAAO,IACX,QACI,OAAOF,GAsFnB,SAASG,EAMDC,GAAA,IAAAC,EAAA,IANkBC,SACtBA,EADsBC,UAEtBA,EAFsBC,aAGtBA,EAAeT,EAHOU,MAItBA,GAA4BC,OAApBC,EAAAA,UAAUC,eAAUF,EAAAA,EAAAA,cAAcG,SAAS,UAAU,GAEzDT,EADDU,EACCC,EAAAC,wBAAAZ,EAAAa,GACJ,MAAMC,EAAgC,iBAAbZ,EAAwB,CAACA,GAAYA,EAC9D,OACIa,uBAAAC,gBAAA,CACIb,UAAWc,EAAAA,QAAW,6BAA8Bd,EAAW,CAC3De,oCAAqCb,KAErCK,GAEHI,EAAUK,IAAI,CAACC,EAAUC,IACtBN,EAACO,cAAAP,EAAMQ,SAAQ,CAAC3B,IAAKyB,GACV,IAANA,EAAU,KAAO,KAClBN,EAAAO,cAAA,MAAA,KApFpB,SAAmBF,EAAkBf,EAAgBD,GACjD,MAAMoB,EAAInB,EAAQR,EAAkBO,EAC9BqB,EATC,wCAAwCC,KASZN,GAgBnC,OAJKf,IACDe,EAAWA,EAASO,QAAQ,iBAAkB,SAG3CP,EAASQ,MAAM,YAAYT,KAdlC,SAA0BU,GACtB,OATR,SAAsBA,GAClB,MAAO,kDAAkDH,KAAKG,GAQtDC,CAAaD,GAjBzB,SAAoBA,GAChB,OAAOA,EAAIE,OAAO,GAAGzB,cAAgBuB,EAAIG,MAAM,GAAGlC,cAiBnCmC,CAAWT,EAAEK,IAEpBJ,GAAgC,IAAfI,EAAIK,OACdL,EAAIvB,cAERuB,KA0EUM,CAAUf,EAAUf,EAAOD,GAAce,IAAI,CAACvB,EAAKwC,IAChDrB,EAAKO,cAAA,MAAA,CAAA1B,IAAKwC,GAAIxC,QA7H1CG,EAAiBsC,gBAAmBC,IAChC3C,EAAqB2C"}
+{"version":3,"file":"keyboard-shortcut.js","sources":["../../../src/components/keyboard-shortcut/keyboard-shortcut.tsx"],"sourcesContent":[null],"names":["__rest","React","classNames"],"mappings":"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"}

package/lib/components/progress-bar/index.d.ts

@@ -1,2 +1,2 @@
-import { ProgressBar } from './progress-bar';
-export default ProgressBar;
+import { ProgressBar } from './progress-bar';
+export default ProgressBar;

package/lib/components/progress-bar/index.js

@@ -1,2 +1,10 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./progress-bar.js");exports.default=e.ProgressBar;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var progressBar = require('./progress-bar.js');
+
+
+
+exports["default"] = progressBar.ProgressBar;
 //# sourceMappingURL=index.js.map

package/lib/components/progress-bar/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/lib/components/progress-bar/progress-bar.d.ts

@@ -1,14 +1,14 @@
-import * as React from 'react';
-type Props = {
-    /** Additional css class applied to the progress bar. */
-    className?: string;
-    /** How much of the progress bar should be filled. Number between 0 and 100 inclusive. */
-    fillPercentage?: number;
-    /** Defines the human readable text alternative for assitive technologies. */
-    'aria-valuetext'?: string;
-};
-declare function ProgressBar({ fillPercentage, className, 'aria-valuetext': ariaValuetext }: Props): React.JSX.Element;
-declare namespace ProgressBar {
-    var displayName: string;
-}
-export { ProgressBar };
+import * as React from 'react';
+type Props = {
+    /** Additional css class applied to the progress bar. */
+    className?: string;
+    /** How much of the progress bar should be filled. Number between 0 and 100 inclusive. */
+    fillPercentage?: number;
+    /** Defines the human readable text alternative for assitive technologies. */
+    'aria-valuetext'?: string;
+};
+declare function ProgressBar({ fillPercentage, className, 'aria-valuetext': ariaValuetext }: Props): React.JSX.Element;
+declare namespace ProgressBar {
+    var displayName: string;
+}
+export { ProgressBar };