lecom-ui 4.1.9 → 4.2.1

package/dist/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,56 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+var __assign = function() {
+  __assign = Object.assign || function __assign(t) {
+      for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+      return t;
+  };
+  return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+      t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+              t[p[i]] = s[p[i]];
+      }
+  return t;
+}
+
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+      }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __assign, __rest, __spreadArray };

package/dist/node_modules/use-callback-ref/dist/es2015/assignRef.js

@@ -0,0 +1,24 @@
+/**
+ * Assigns a value for a given ref, no matter of the ref format
+ * @param {RefObject} ref - a callback function or ref object
+ * @param value - a new value
+ *
+ * @see https://github.com/theKashey/use-callback-ref#assignref
+ * @example
+ * const refObject = useRef();
+ * const refFn = (ref) => {....}
+ *
+ * assignRef(refObject, "refValue");
+ * assignRef(refFn, "refValue");
+ */
+function assignRef(ref, value) {
+    if (typeof ref === 'function') {
+        ref(value);
+    }
+    else if (ref) {
+        ref.current = value;
+    }
+    return ref;
+}
+
+export { assignRef };

package/dist/node_modules/use-callback-ref/dist/es2015/useMergeRef.js

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import { assignRef } from './assignRef.js';
+import { useCallbackRef } from './useRef.js';
+
+var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;
+var currentValues = new WeakMap();
+/**
+ * Merges two or more refs together providing a single interface to set their value
+ * @param {RefObject|Ref} refs
+ * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}
+ *
+ * @see {@link mergeRefs} a version without buit-in memoization
+ * @see https://github.com/theKashey/use-callback-ref#usemergerefs
+ * @example
+ * const Component = React.forwardRef((props, ref) => {
+ *   const ownRef = useRef();
+ *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together
+ *   return <div ref={domRef}>...</div>
+ * }
+ */
+function useMergeRefs(refs, defaultValue) {
+    var callbackRef = useCallbackRef(null, function (newValue) {
+        return refs.forEach(function (ref) { return assignRef(ref, newValue); });
+    });
+    // handle refs changes - added or removed
+    useIsomorphicLayoutEffect(function () {
+        var oldValue = currentValues.get(callbackRef);
+        if (oldValue) {
+            var prevRefs_1 = new Set(oldValue);
+            var nextRefs_1 = new Set(refs);
+            var current_1 = callbackRef.current;
+            prevRefs_1.forEach(function (ref) {
+                if (!nextRefs_1.has(ref)) {
+                    assignRef(ref, null);
+                }
+            });
+            nextRefs_1.forEach(function (ref) {
+                if (!prevRefs_1.has(ref)) {
+                    assignRef(ref, current_1);
+                }
+            });
+        }
+        currentValues.set(callbackRef, refs);
+    }, [refs]);
+    return callbackRef;
+}
+
+export { useMergeRefs };

package/dist/node_modules/use-callback-ref/dist/es2015/useRef.js

@@ -0,0 +1,42 @@
+import { useState } from 'react';
+
+/**
+ * creates a MutableRef with ref change callback
+ * @param initialValue - initial ref value
+ * @param {Function} callback - a callback to run when value changes
+ *
+ * @example
+ * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);
+ * ref.current = 1;
+ * // prints 0 -> 1
+ *
+ * @see https://reactjs.org/docs/hooks-reference.html#useref
+ * @see https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref
+ * @returns {MutableRefObject}
+ */
+function useCallbackRef(initialValue, callback) {
+    var ref = useState(function () { return ({
+        // value
+        value: initialValue,
+        // last callback
+        callback: callback,
+        // "memoized" public interface
+        facade: {
+            get current() {
+                return ref.value;
+            },
+            set current(value) {
+                var last = ref.value;
+                if (last !== value) {
+                    ref.value = value;
+                    ref.callback(value, last);
+                }
+            },
+        },
+    }); })[0];
+    // update callback
+    ref.callback = callback;
+    return ref.facade;
+}
+
+export { useCallbackRef };

package/dist/node_modules/use-color-luminance/index.es.js

@@ -0,0 +1,105 @@
+import 'react';
+
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var RGBA_PATTERN = /rgba?\(([0-9]+),([0-9]+),([0-9]+)(?:,(1|0|0?\.[0-9]*))?\)/;
+var CACHE = {};
+/**
+ * Calculates the color's luminance
+ *
+ * @param color #rgb, #rrggbb[FF], rgb(r,g,b), rgba(r,g,b,1) or [r, g, b]
+ */
+function colorLuminance(color, cache) {
+    if (cache === void 0) { cache = true; }
+    if (typeof color === 'string') {
+        if (cache && CACHE[color]) {
+            return CACHE[color];
+        }
+        if (color[0] === '#') {
+            var rgb = color.slice(1);
+            if (rgb.length === 3) {
+                return (CACHE[color] = colorLuminance([
+                    hexToByte(rgb[0] + rgb[0]),
+                    hexToByte(rgb[1] + rgb[1]),
+                    hexToByte(rgb[2] + rgb[2]),
+                ]));
+            }
+            if (rgb.length === 8) {
+                var alpha = hexToByte(rgb.slice(6, 8));
+                if (alpha !== 255) {
+                    throw new NeedsAlphaBlending(color, alpha);
+                }
+            }
+            if (rgb.length === 6 || rgb.length === 8) {
+                return (CACHE[color] = colorLuminance([
+                    hexToByte(rgb.slice(0, 2)),
+                    hexToByte(rgb.slice(2, 4)),
+                    hexToByte(rgb.slice(4, 6)),
+                ]));
+            }
+            throw new UnsupportedFormat(color);
+        }
+        var matches = color.replace(/ /g, '').match(RGBA_PATTERN);
+        if (matches) {
+            if (matches[4] && matches[4] !== '1') {
+                throw new NeedsAlphaBlending(color, Number(matches[4]));
+            }
+            return (CACHE[color] = colorLuminance([
+                Number(matches[1]),
+                Number(matches[2]),
+                Number(matches[3]),
+            ]));
+        }
+        throw new UnsupportedFormat(color);
+    }
+    assertRgbColor(color);
+    return componentsToLuminance(color[0] / 255, color[1] / 255, color[2] / 255);
+}
+function hexToByte(hex) {
+    return parseInt(hex, 16);
+}
+function componentsToLuminance(r, g, b) {
+    var rl = r > 0.03928 ? Math.pow(((r + 0.055) / 1.055), 2.4) : r / 12.92;
+    var gl = g > 0.03928 ? Math.pow(((g + 0.055) / 1.055), 2.4) : g / 12.92;
+    var bl = b > 0.03928 ? Math.pow(((b + 0.055) / 1.055), 2.4) : b / 12.92;
+    // https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
+    // https://en.wikipedia.org/wiki/Relative_luminance
+    return 0.2126 * rl + 0.7152 * gl + 0.0722 * bl;
+}
+function assertRgbColor(color) {
+    if (color.length < 3 ||
+        color.length > 4 ||
+        color.some(function (d) { return d < 0 || d > 255; })) {
+        throw new UnsupportedFormat("[" + color.join(', ') + "]");
+    }
+    if (color.length == 4 && color[3] !== 1) {
+        throw new NeedsAlphaBlending("[" + color.join(', ') + "]", color[3]);
+    }
+}
+var UnsupportedFormat = /** @class */ (function (_super) {
+    __extends(UnsupportedFormat, _super);
+    function UnsupportedFormat(color) {
+        return _super.call(this, ("\nExpected color to be in a supported format, actual: " + color + ".\n\nSupported formats for string input are:\n\n- #rgb\n- #rrggbb\n- #rrggbbFF\n- rgb(r, g, b)      (0 <= rgb <= 255)\n- rgba(r, g, b, 1)  (0 <= rgb <= 255)\n\nSupported formats for array input are:\n\n - [r, g, b]         (0 <= rgb <= 255)\n - [r, g, b, 1]      (0 <= rgb <= 255)\n\nKeyword/system colors are not supported (nor consistent across environments).\n      ").trim()) || this;
+    }
+    return UnsupportedFormat;
+}(Error));
+var NeedsAlphaBlending = /** @class */ (function (_super) {
+    __extends(NeedsAlphaBlending, _super);
+    function NeedsAlphaBlending(color, alpha) {
+        return _super.call(this, ("\nExpected a fully opaque color, actual: " + color + ", with alpha: " + alpha + ".\n\nColors with that are (semi-)translucent need to be alpha-blended, which means\nthat you need to know the background color(s) in order to calculate the color\nthat will show on screen.\n\nThe package use-alpha-blended-color has both a React hook as well as a general\nutility function to premultiply colors.\n\n  import { useAlphaBlendedColor } from 'use-alpha-blended-color'\n\n  const prepared = useAlphaBlendedColor(" + color + ", '#<background-color>')\n  const luminance = useColorLuminance(prepared)\n      ").trim()) || this;
+    }
+    return NeedsAlphaBlending;
+}(Error));
+
+export { NeedsAlphaBlending, UnsupportedFormat, colorLuminance };

package/dist/node_modules/use-sidecar/dist/es2015/exports.js

@@ -0,0 +1,21 @@
+import { __rest, __assign } from '../../../tslib/tslib.es6.js';
+import * as React from 'react';
+
+var SideCar = function (_a) {
+    var sideCar = _a.sideCar, rest = __rest(_a, ["sideCar"]);
+    if (!sideCar) {
+        throw new Error('Sidecar: please provide `sideCar` property to import the right car');
+    }
+    var Target = sideCar.read();
+    if (!Target) {
+        throw new Error('Sidecar medium not found');
+    }
+    return React.createElement(Target, __assign({}, rest));
+};
+SideCar.isSideCarExport = true;
+function exportSidecar(medium, exported) {
+    medium.useMedium(exported);
+    return SideCar;
+}
+
+export { exportSidecar };

package/dist/node_modules/use-sidecar/dist/es2015/medium.js

@@ -0,0 +1,77 @@
+import { __assign } from '../../../tslib/tslib.es6.js';
+
+function ItoI(a) {
+    return a;
+}
+function innerCreateMedium(defaults, middleware) {
+    if (middleware === void 0) { middleware = ItoI; }
+    var buffer = [];
+    var assigned = false;
+    var medium = {
+        read: function () {
+            if (assigned) {
+                throw new Error('Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.');
+            }
+            if (buffer.length) {
+                return buffer[buffer.length - 1];
+            }
+            return defaults;
+        },
+        useMedium: function (data) {
+            var item = middleware(data, assigned);
+            buffer.push(item);
+            return function () {
+                buffer = buffer.filter(function (x) { return x !== item; });
+            };
+        },
+        assignSyncMedium: function (cb) {
+            assigned = true;
+            while (buffer.length) {
+                var cbs = buffer;
+                buffer = [];
+                cbs.forEach(cb);
+            }
+            buffer = {
+                push: function (x) { return cb(x); },
+                filter: function () { return buffer; },
+            };
+        },
+        assignMedium: function (cb) {
+            assigned = true;
+            var pendingQueue = [];
+            if (buffer.length) {
+                var cbs = buffer;
+                buffer = [];
+                cbs.forEach(cb);
+                pendingQueue = buffer;
+            }
+            var executeQueue = function () {
+                var cbs = pendingQueue;
+                pendingQueue = [];
+                cbs.forEach(cb);
+            };
+            var cycle = function () { return Promise.resolve().then(executeQueue); };
+            cycle();
+            buffer = {
+                push: function (x) {
+                    pendingQueue.push(x);
+                    cycle();
+                },
+                filter: function (filter) {
+                    pendingQueue = pendingQueue.filter(filter);
+                    return buffer;
+                },
+            };
+        },
+    };
+    return medium;
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+function createSidecarMedium(options) {
+    if (options === void 0) { options = {}; }
+    var medium = innerCreateMedium(null);
+    medium.options = __assign({ async: true, ssr: false }, options);
+    return medium;
+}
+
+export { createSidecarMedium };

package/dist/plugin/typographies.ts

@@ -1,152 +1,146 @@
-const montSerrat = { fontFamily: 'Montserrat, sans-serif' };
-const roboto = { fontFamily: 'Roboto, sans-serif' };
-const ibm = { fontFamily: 'IBM Plex Mono, sans-serif' };
-const fontWeight700 = { fontWeight: '700' };
-const fontWeight600 = { fontWeight: '600' };
-const fontWeight500 = { fontWeight: '500' };
-const fontWeight400 = { fontWeight: '400' };
-const fontSize3 = { fontSize: '3rem' };
-const fontSize2 = { fontSize: '2rem' };
-const fontSize25 = { fontSize: '2.5rem' };
-const fontSize15 = { fontSize: '1.5rem' };
-const fontSize125 = { fontSize: '1.25rem' };
-const fontSize1 = { fontSize: '1rem' };
-const fontSize0875 = { fontSize: '0.875rem' };
-const fontSize075 = { fontSize: '0.75rem' };
-
-const typographies = {
-  '.heading-xxlarge-500': {
-    ...montSerrat,
-    ...fontSize3,
-    ...fontWeight500,
-    lineHeight: '3.25rem',
-  },
-  '.heading-xlarge-500': {
-    ...montSerrat,
-    ...fontSize25,
-    ...fontWeight500,
-    lineHeight: '2.75rem',
-  },
-  '.heading-large-600': {
-    ...montSerrat,
-    ...fontSize2,
-    ...fontWeight600,
-    lineHeight: '2.25rem',
-  },
-  '.heading-large-500': {
-    ...montSerrat,
-    ...fontSize2,
-    ...fontWeight500,
-    lineHeight: '2.25rem',
-  },
-  '.heading-medium-600': {
-    ...montSerrat,
-    ...fontSize15,
-    ...fontWeight600,
-    lineHeight: '1.75rem',
-  },
-  '.heading-medium-500': {
-    ...montSerrat,
-    ...fontSize15,
-    ...fontWeight500,
-    lineHeight: '1.75rem',
-  },
-  '.heading-small-600': {
-    ...montSerrat,
-    ...fontSize125,
-    ...fontWeight600,
-    lineHeight: '1.5rem',
-  },
-  '.heading-small-500': {
-    ...montSerrat,
-    ...fontSize125,
-    ...fontWeight500,
-    lineHeight: '1.5rem',
-  },
-  '.heading-xsmall-600': {
-    ...montSerrat,
-    ...fontSize1,
-    ...fontWeight600,
-    lineHeight: '1.25rem',
-  },
-  '.heading-xsmall-500': {
-    ...montSerrat,
-    ...fontSize1,
-    ...fontWeight500,
-    lineHeight: '1.25rem',
-  },
-  '.heading-xxsmall-600': {
-    ...montSerrat,
-    ...fontSize0875,
-    lineHeight: '1.25rem',
-    ...fontWeight600,
-  },
-  '.heading-xxsmall-500': {
-    ...montSerrat,
-    ...fontSize0875,
-    lineHeight: '1.25rem',
-    ...fontWeight500,
-  },
-  '.body-large-700': {
-    ...roboto,
-    ...fontSize1,
-    lineHeight: '1.5rem',
-    ...fontWeight700,
-  },
-  '.body-large-500': {
-    ...roboto,
-    ...fontSize1,
-    lineHeight: '1.5rem',
-    ...fontWeight500,
-  },
-  '.body-large-400': {
-    ...roboto,
-    ...fontSize1,
-    lineHeight: '1.5rem',
-    ...fontWeight400,
-  },
-  '.body-medium-700': {
-    ...roboto,
-    ...fontSize0875,
-    lineHeight: '1.25rem',
-    ...fontWeight700,
-  },
-  '.body-medium-500': {
-    ...roboto,
-    ...fontSize0875,
-    lineHeight: '1.25rem',
-    ...fontWeight500,
-  },
-  '.body-medium-400': {
-    ...roboto,
-    ...fontSize0875,
-    lineHeight: '1.25rem',
-    ...fontWeight400,
-  },
-  '.body-small-700': {
-    ...roboto,
-    ...fontSize075,
-    lineHeight: '1rem',
-    ...fontWeight700,
-  },
-  '.body-small-500': {
-    ...roboto,
-    ...fontSize075,
-    lineHeight: '1rem',
-    ...fontWeight500,
-  },
-  '.body-small-400': {
-    ...roboto,
-    ...fontSize075,
-    lineHeight: '1rem',
-    ...fontWeight400,
-  },
-  '.code-medium-400': {
-    ...ibm,
-    ...fontSize0875,
-    lineHeight: '1.25rem',
-    ...fontWeight400,
-  },
-};
-
-export { typographies };
+const montSerrat = { fontFamily: 'Montserrat, sans-serif' };
+const roboto = { fontFamily: 'Roboto, sans-serif' };
+const ibm = { fontFamily: 'IBM Plex Mono, sans-serif' };
+const fontWeight700 = { fontWeight: '700' };
+const fontWeight600 = { fontWeight: '600' };
+const fontWeight500 = { fontWeight: '500' };
+const fontWeight400 = { fontWeight: '400' };
+const fontSize3 = { fontSize: '3rem' };
+const fontSize2 = { fontSize: '2rem' };
+const fontSize25 = { fontSize: '2.5rem' };
+const fontSize15 = { fontSize: '1.5rem' };
+const fontSize125 = { fontSize: '1.25rem' };
+const fontSize1 = { fontSize: '1rem' };
+const fontSize0875 = { fontSize: '0.875rem' };
+const fontSize075 = { fontSize: '0.75rem' };
+
+const typographies = {
+  '.heading-xxlarge-500': {
+    ...montSerrat,
+    ...fontSize3,
+    ...fontWeight500,
+    lineHeight: '3.25rem',
+  },
+  '.heading-xlarge-500': {
+    ...montSerrat,
+    ...fontSize25,
+    ...fontWeight500,
+    lineHeight: '2.75rem',
+  },
+  '.heading-large-600': {
+    ...montSerrat,
+    ...fontSize2,
+    ...fontWeight600,
+    lineHeight: '2.25rem',
+  },
+  '.heading-large-500': {
+    ...montSerrat,
+    ...fontSize2,
+    ...fontWeight500,
+    lineHeight: '2.25rem',
+  },
+  '.heading-medium-600': {
+    ...montSerrat,
+    ...fontSize15,
+    ...fontWeight600,
+    lineHeight: '1.75rem',
+  },
+  '.heading-medium-500': {
+    ...montSerrat,
+    ...fontSize15,
+    ...fontWeight500,
+    lineHeight: '1.75rem',
+  },
+  '.heading-small-600': {
+    ...montSerrat,
+    ...fontSize125,
+    ...fontWeight600,
+    lineHeight: '1.5rem',
+  },
+  '.heading-small-500': {
+    ...montSerrat,
+    ...fontSize125,
+    ...fontWeight500,
+    lineHeight: '1.5rem',
+  },
+  '.heading-xsmall-600': {
+    ...montSerrat,
+    ...fontSize1,
+    ...fontWeight600,
+    lineHeight: '1.25rem',
+  },
+  '.heading-xsmall-500': {
+    ...montSerrat,
+    ...fontSize1,
+    ...fontWeight500,
+    lineHeight: '1.25rem',
+  },
+  '.heading-xxsmall-500': {
+    ...montSerrat,
+    ...fontSize0875,
+    lineHeight: '1.25rem',
+    ...fontWeight500,
+  },
+  '.body-large-700': {
+    ...roboto,
+    ...fontSize1,
+    lineHeight: '1.5rem',
+    ...fontWeight700,
+  },
+  '.body-large-500': {
+    ...roboto,
+    ...fontSize1,
+    lineHeight: '1.5rem',
+    ...fontWeight500,
+  },
+  '.body-large-400': {
+    ...roboto,
+    ...fontSize1,
+    lineHeight: '1.5rem',
+    ...fontWeight400,
+  },
+  '.body-medium-700': {
+    ...roboto,
+    ...fontSize0875,
+    lineHeight: '1.25rem',
+    ...fontWeight700,
+  },
+  '.body-medium-500': {
+    ...roboto,
+    ...fontSize0875,
+    lineHeight: '1.25rem',
+    ...fontWeight500,
+  },
+  '.body-medium-400': {
+    ...roboto,
+    ...fontSize0875,
+    lineHeight: '1.25rem',
+    ...fontWeight400,
+  },
+  '.body-small-700': {
+    ...roboto,
+    ...fontSize075,
+    lineHeight: '1rem',
+    ...fontWeight700,
+  },
+  '.body-small-500': {
+    ...roboto,
+    ...fontSize075,
+    lineHeight: '1rem',
+    ...fontWeight500,
+  },
+  '.body-small-400': {
+    ...roboto,
+    ...fontSize075,
+    lineHeight: '1rem',
+    ...fontWeight400,
+  },
+  '.code-medium-400': {
+    ...ibm,
+    ...fontSize0875,
+    lineHeight: '1.25rem',
+    ...fontWeight400,
+  },
+};
+
+export { typographies };