lecom-ui 5.4.35 → 5.4.36

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/extend.ts

@@ -0,0 +1,78 @@
+const extend = {
+  colors: {
+    background: 'hsl(var(--background))',
+    foreground: 'hsl(var(--foreground))',
+    card: {
+      DEFAULT: 'hsl(var(--card))',
+      foreground: 'hsl(var(--card-foreground))',
+    },
+    popover: {
+      DEFAULT: 'hsl(var(--popover))',
+      foreground: 'hsl(var(--popover-foreground))',
+    },
+    primary: {
+      DEFAULT: 'hsl(var(--primary))',
+      foreground: 'hsl(var(--primary-foreground))',
+    },
+    secondary: {
+      DEFAULT: 'hsl(var(--secondary))',
+      foreground: 'hsl(var(--secondary-foreground))',
+    },
+    muted: {
+      DEFAULT: 'hsl(var(--muted))',
+      foreground: 'hsl(var(--muted-foreground))',
+    },
+    accent: {
+      DEFAULT: 'hsl(var(--accent))',
+      foreground: 'hsl(var(--accent-foreground))',
+    },
+    destructive: {
+      DEFAULT: 'hsl(var(--destructive))',
+      foreground: 'hsl(var(--destructive-foreground))',
+    },
+    border: 'hsl(var(--border))',
+    input: 'hsl(var(--input))',
+    ring: 'hsl(var(--ring))',
+    chart: {
+      1: 'hsl(var(--chart-1))',
+      2: 'hsl(var(--chart-2))',
+      3: 'hsl(var(--chart-3))',
+      4: 'hsl(var(--chart-4))',
+      5: 'hsl(var(--chart-5))',
+      6: 'hsl(var(--chart-6))',
+      7: 'hsl(var(--chart-7))',
+      8: 'hsl(var(--chart-8))',
+    },
+    sidebar: {
+      DEFAULT: 'hsl(var(--sidebar-background))',
+      foreground: 'hsl(var(--sidebar-foreground))',
+      primary: 'hsl(var(--sidebar-primary))',
+      'primary-foreground': 'hsl(var(--sidebar-primary-foreground))',
+      accent: 'hsl(var(--sidebar-accent))',
+      'accent-foreground': 'hsl(var(--sidebar-accent-foreground))',
+      border: 'hsl(var(--sidebar-border))',
+      ring: 'hsl(var(--sidebar-ring))',
+    },
+  },
+  borderRadius: {
+    lg: 'var(--radius)',
+    md: 'calc(var(--radius) - 2px)',
+    sm: 'calc(var(--radius) - 4px)',
+  },
+  keyframes: {
+    'accordion-down': {
+      from: { height: '0' },
+      to: { height: 'var(--radix-accordion-content-height)' },
+    },
+    'accordion-up': {
+      from: { height: 'var(--radix-accordion-content-height)' },
+      to: { height: '0' },
+    },
+  },
+  animation: {
+    'accordion-down': 'accordion-down 0.2s ease-out',
+    'accordion-up': 'accordion-up 0.2s ease-out',
+  },
+};
+
+export { extend };

package/dist/plugin/fontFaces.ts

@@ -0,0 +1,172 @@
+const fontFaces = (publicPath: string) => [
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'italic',
+    fontWeight: '100',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/thin-100-italic.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'italic',
+    fontWeight: '300',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/light-300-italic.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'italic',
+    fontWeight: '400',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/regular-400-italic.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'italic',
+    fontWeight: '500',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/medium-500-italic.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'italic',
+    fontWeight: '700',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/bold-700-italic.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'italic',
+    fontWeight: '900',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/black-900-italic.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'normal',
+    fontWeight: '100',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/thin-100.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'normal',
+    fontWeight: '300',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/light-300.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'normal',
+    fontWeight: '400',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/regular-400.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'normal',
+    fontWeight: '500',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/medium-500.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'normal',
+    fontWeight: '700',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/bold-700.woff2')`,
+  },
+  {
+    fontFamily: 'Roboto',
+    fontStyle: 'normal',
+    fontWeight: '900',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Roboto/black-900.woff2')`,
+  },
+  {
+    fontFamily: 'Montserrat',
+    fontStyle: 'italic',
+    fontWeight: '100 900',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Montserrat/italic.woff2')`,
+  },
+  {
+    fontFamily: 'Montserrat',
+    fontStyle: 'normal',
+    fontWeight: '100 900',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Montserrat/normal.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'italic',
+    fontWeight: '100',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/thin-100-italic.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'italic',
+    fontWeight: '300',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/light-300-italic.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'italic',
+    fontWeight: '400',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/regular-400-italic.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'italic',
+    fontWeight: '500',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/medium-500-italic.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'italic',
+    fontWeight: '700',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/bold-700-italic.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'normal',
+    fontWeight: '100',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/thin-100.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'normal',
+    fontWeight: '300',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/light-300.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'normal',
+    fontWeight: '400',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/regular-400.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'normal',
+    fontWeight: '500',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/medium-500.woff2')`,
+  },
+  {
+    fontFamily: 'IBM Plex Mono',
+    fontStyle: 'normal',
+    fontWeight: '700',
+    fontDisplay: 'swap',
+    src: `url('${publicPath}/fonts/Ibm/bold-700.woff2')`,
+  },
+];
+
+export { fontFaces };

package/dist/plugin/general.ts

@@ -0,0 +1,12 @@
+const general = {
+  '*': {
+    borderColor: 'hsl(var(--border))',
+  },
+  body: {
+    backgroundColor: 'hsl(var(--background))',
+    fontFamily: 'Roboto, sans-serif',
+    color: 'hsl(var(--foreground))',
+  },
+};
+
+export { general };

package/dist/plugin/plugin.cjs

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const buildPlugin = require('./template').buildPlugin;
+
+console.log('>>>>>>>>>>>>>>', process.env);
+
+module.exports = buildPlugin('lecom-ui/dist/public');

package/dist/plugin/pluginNext.cjs

@@ -1,5 +1,5 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-
-const buildPlugin = require('./template').buildPlugin;
-
-module.exports = buildPlugin('~/node_modules/lecom-ui/dist/public');
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const buildPlugin = require('./template').buildPlugin;
+
+module.exports = buildPlugin('~/node_modules/lecom-ui/dist/public');

package/dist/plugin/pluginVite.cjs

@@ -1,5 +1,5 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-
-const buildPlugin = require('./template').buildPlugin;
-
-module.exports = buildPlugin('/node_modules/lecom-ui/dist/public');
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const buildPlugin = require('./template').buildPlugin;
+
+module.exports = buildPlugin('/node_modules/lecom-ui/dist/public');