josenanodev-react-components-library 1.0.3 → 1.0.4

package/dist/cjs/components/SideBar/SideBar.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+require("./SideBar.css");
+//Hooks
+const useOutsideClick_1 = __importDefault(require("../../hooks/useOutsideClick"));
+const useResizeObserver_1 = __importDefault(require("../../hooks/useResizeObserver"));
+//Icons
+const bs_1 = require("react-icons/bs");
+/**
+ * NOTE: Parent Node must have position: relative, to work correctly with the side bar
+ */
+const SideBar = ({ side, open = false, children, closeAction, outBoundClickClosesSideBar, aditionalInlineStyle = {}, }) => {
+    //Refs
+    const sideBarRef = (0, react_1.useRef)(null);
+    //Hooks
+    const [elementWidth] = (0, useResizeObserver_1.default)(sideBarRef);
+    (0, useOutsideClick_1.default)(sideBarRef, () => {
+        if (outBoundClickClosesSideBar)
+            if (closeAction) {
+                closeAction();
+            }
+            else {
+                setOpenState(false);
+            }
+    });
+    //useState
+    const [openState, setOpenState] = (0, react_1.useState)(open);
+    return (react_1.default.createElement("div", { ref: sideBarRef, className: "trc-side-bar", style: Object.assign({ [side === "left" ? "right" : "left"]: (closeAction && open) || (!closeAction && openState)
+                ? `calc(100% - ${elementWidth}px)`
+                : closeAction
+                    ? "100%"
+                    : `calc(100% - 30px)` }, aditionalInlineStyle) },
+        react_1.default.createElement("button", { style: side === "left" ? { right: 0 } : { left: 0 }, className: "sidebar-close-button", onClick: () => {
+                if (closeAction) {
+                    closeAction();
+                }
+                else {
+                    setOpenState(!openState);
+                }
+            } }, side === "left" ? (react_1.default.createElement(bs_1.BsChevronLeft, { className: (closeAction && open) || (!closeAction && openState) ? "open" : "close" })) : (react_1.default.createElement(bs_1.BsChevronRight, { className: (closeAction && open) || (!closeAction && openState) ? "open" : "close" }))),
+        children));
+};
+exports.default = SideBar;

package/dist/cjs/components/SideBar/types.d.ts

@@ -0,0 +1,8 @@
+export interface SideBarPropsType {
+  side: "left" | "right";
+  children: JSX.Element | JSX.Element[];
+  open: boolean;
+  closeAction?: Function;
+  outBoundClickClosesSideBar?: boolean;
+  aditionalInlineStyle?: React.CSSProperties;
+}

package/dist/cjs/components/Slider/Slider.css

@@ -0,0 +1,55 @@
+.trc-slider {
+  display: flex;
+  align-items: center;
+}
+
+.trc-slider.disabled{
+  opacity: 0.7;
+}
+
+.trc-slider .left-fill {
+  border: 2px solid rgb(216, 216, 216);
+  background-color: var(--secondary-color);
+}
+
+.trc-slider .right-fill {
+  border: 2px solid rgb(216, 216, 216);
+  background-color: rgb(211, 211, 211);
+}
+
+.trc-slider .sphere {
+  border-radius: 100%;
+  box-shadow: 0px 0px 20px 2px #a7a7a7;
+  background-color: rgb(255, 255, 255);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: grab;
+  z-index: 2;
+}
+
+.trc-slider .sphere p {
+  margin: 0;
+  font-size: 12px;
+  font-weight: 600;
+  color: #757575;
+  width: 25%;
+}
+
+.trc-slider .sphere input {
+  width: 70%;
+  border: none;
+  background-color: transparent;
+  text-align: right;
+  font-size: 12px;
+  font-weight: 600;
+  color: #757575;
+}
+
+.trc-slider .sphere input::-webkit-inner-spin-button {
+  display: none;
+}
+
+.trc-slider .sphere input:focus {
+  outline: none;
+}

package/dist/cjs/components/Slider/Slider.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import "./Slider.css";
+import { SliderPropsType } from "./types";
+declare const Slider: ({ minimumValue, maximumValue, onChange, initialValue, value, showValueInsideButton, editableValueInsideButton, height, width, sufix, prefix, disabled, }: SliderPropsType) => React.JSX.Element;
+export default Slider;

package/dist/cjs/components/Slider/Slider.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const ownFunctions = __importStar(require("./SliderOwnFunctions"));
+require("./Slider.css");
+const Slider = ({ minimumValue, maximumValue, onChange, initialValue = 0, value, showValueInsideButton, editableValueInsideButton, height = 40, width = 300, sufix, prefix, disabled, }) => {
+    //Refs
+    const sliderRef = (0, react_1.useRef)(null);
+    //Estados
+    const [position, setPosition] = (0, react_1.useState)(initialValue !== undefined
+        ? ownFunctions.definePostionByValue(initialValue, width, maximumValue, minimumValue)
+        : width / 2);
+    const [visibleValue, setVisibleValue] = (0, react_1.useState)(initialValue);
+    const [temporalVisibleValue, setTemporalVisibleValue] = (0, react_1.useState)(undefined);
+    const [cancelTransition, setCancelTransition] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        if (value !== undefined) {
+            setVisibleValue(value);
+            setPosition(ownFunctions.definePostionByValue(value, width, maximumValue, minimumValue));
+        }
+    }, [value, width, maximumValue, minimumValue]);
+    return (react_1.default.createElement("div", { ref: sliderRef, style: { width: width, height: height }, className: `trc-slider ${disabled ? "disabled" : ""}`, onMouseDown: (event1) => {
+            if (!disabled) {
+                var nuevovisibleValue;
+                if (sliderRef.current !== null && sliderRef.current !== undefined) {
+                    setCancelTransition(false);
+                    const newPosition = event1.clientX - sliderRef.current.getBoundingClientRect().x;
+                    setPosition(newPosition);
+                    nuevovisibleValue = ownFunctions.defineVisibleValue(newPosition, width, maximumValue, minimumValue);
+                    setVisibleValue(nuevovisibleValue);
+                }
+                function repositioning(event2) {
+                    setCancelTransition(true);
+                    if (sliderRef.current !== null && sliderRef.current !== undefined) {
+                        setTemporalVisibleValue(undefined);
+                        let newPosition = event2.clientX - sliderRef.current.getBoundingClientRect().x;
+                        if (newPosition < 0)
+                            newPosition = 0;
+                        if (newPosition > width)
+                            newPosition = width;
+                        setPosition(newPosition);
+                        nuevovisibleValue = ownFunctions.defineVisibleValue(newPosition, width, maximumValue, minimumValue);
+                        setVisibleValue(nuevovisibleValue);
+                    }
+                }
+                document.addEventListener("mousemove", repositioning);
+                function removeEventListeners() {
+                    document.removeEventListener("mousemove", repositioning);
+                    document.removeEventListener("mouseup", removeEventListeners);
+                    setCancelTransition(false);
+                    onChange(nuevovisibleValue);
+                }
+                document.addEventListener("mouseup", removeEventListeners);
+            }
+        }, onTouchStart: (event1) => {
+            if (!disabled) {
+                var nuevovisibleValue;
+                if (sliderRef.current !== null && sliderRef.current !== undefined) {
+                    setCancelTransition(false);
+                    const newPosition = event1.touches[0].clientX - sliderRef.current.getBoundingClientRect().x;
+                    setPosition(newPosition);
+                    nuevovisibleValue = ownFunctions.defineVisibleValue(newPosition, width, maximumValue, minimumValue);
+                    setVisibleValue(nuevovisibleValue);
+                }
+                function repositioning(event2) {
+                    setCancelTransition(true);
+                    if (sliderRef.current !== null && sliderRef.current !== undefined) {
+                        setTemporalVisibleValue(undefined);
+                        let newPosition = event2.touches[0].clientX - sliderRef.current.getBoundingClientRect().x;
+                        if (newPosition < 0)
+                            newPosition = 0;
+                        if (newPosition > width)
+                            newPosition = width;
+                        setPosition(newPosition);
+                        nuevovisibleValue = ownFunctions.defineVisibleValue(newPosition, width, maximumValue, minimumValue);
+                        setVisibleValue(nuevovisibleValue);
+                    }
+                }
+                document.addEventListener("touchmove", repositioning);
+                function removeEventListeners() {
+                    document.removeEventListener("touchmove", repositioning);
+                    document.removeEventListener("touchend", removeEventListeners);
+                    setCancelTransition(false);
+                    onChange(nuevovisibleValue);
+                }
+                document.addEventListener("touchend", removeEventListeners);
+            }
+        } },
+        react_1.default.createElement("div", { style: {
+                width: position,
+                height: height * 0.8,
+                borderTopLeftRadius: (height * 0.8) / 2,
+                borderBottomLeftRadius: (height * 0.8) / 2,
+                marginRight: -height / 2,
+                transition: cancelTransition ? "none" : "all 0.3s",
+            }, className: "left-fill" }),
+        react_1.default.createElement("div", { style: { width: height, height: height }, className: "sphere" }, showValueInsideButton && (react_1.default.createElement(react_1.Fragment, null,
+            prefix !== undefined && react_1.default.createElement("p", null, prefix),
+            react_1.default.createElement("input", { disabled: !editableValueInsideButton || disabled, type: "number", min: minimumValue, max: maximumValue, value: temporalVisibleValue !== undefined ? temporalVisibleValue : visibleValue, onChange: (event) => {
+                    setTemporalVisibleValue(Number(event.target.value));
+                }, onFocus: () => {
+                    setTemporalVisibleValue(visibleValue);
+                }, onKeyDown: (event) => {
+                    if (!disabled) {
+                        if (event.key === "Enter" && temporalVisibleValue !== undefined) {
+                            let nuevovalue = temporalVisibleValue;
+                            if (nuevovalue < minimumValue)
+                                nuevovalue = minimumValue;
+                            if (nuevovalue > maximumValue)
+                                nuevovalue = maximumValue;
+                            const newPosition = ownFunctions.definePostionByValue(nuevovalue, width, maximumValue, minimumValue);
+                            setPosition(newPosition);
+                            const nuevovisibleValue = ownFunctions.defineVisibleValue(newPosition, width, maximumValue, minimumValue);
+                            setVisibleValue(nuevovisibleValue);
+                            onChange(nuevovisibleValue);
+                            setTemporalVisibleValue(undefined);
+                        }
+                        if (event.key === "Escape") {
+                            setPosition(ownFunctions.definePostionByValue(visibleValue, width, maximumValue, minimumValue));
+                            setTemporalVisibleValue(undefined);
+                        }
+                    }
+                }, onBlur: () => {
+                    if (!disabled) {
+                        if (temporalVisibleValue !== undefined) {
+                            let nuevovalue = temporalVisibleValue;
+                            if (nuevovalue < minimumValue)
+                                nuevovalue = minimumValue;
+                            if (nuevovalue > maximumValue)
+                                nuevovalue = maximumValue;
+                            const newPosition = ownFunctions.definePostionByValue(nuevovalue, width, maximumValue, minimumValue);
+                            setPosition(newPosition);
+                            const nuevovisibleValue = ownFunctions.defineVisibleValue(newPosition, width, maximumValue, minimumValue);
+                            setVisibleValue(nuevovisibleValue);
+                            onChange(nuevovisibleValue);
+                            setTemporalVisibleValue(undefined);
+                        }
+                    }
+                } }),
+            sufix !== undefined && react_1.default.createElement("p", null, sufix)))),
+        react_1.default.createElement("div", { style: {
+                width: width - position,
+                height: height * 0.8,
+                borderTopRightRadius: (height * 0.8) / 2,
+                borderBottomRightRadius: (height * 0.8) / 2,
+                marginLeft: -height / 2,
+                transition: cancelTransition ? "none" : "all 0.3s",
+            }, className: "right-fill" })));
+};
+exports.default = Slider;

package/dist/cjs/components/Slider/SliderOwnFunctions.d.ts

@@ -0,0 +1,2 @@
+export declare function defineVisibleValue(posicion: number, ancho: number, valorMaximo: number, valorMinimo: number): number;
+export declare function definePostionByValue(nuevoValor: number, ancho: number, valorMaximo: number, valorMinimo: number): number;

package/dist/cjs/components/Slider/SliderOwnFunctions.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definePostionByValue = exports.defineVisibleValue = void 0;
+function defineVisibleValue(posicion, ancho, valorMaximo, valorMinimo) {
+    return Math.round((posicion / (ancho)) * (valorMaximo - valorMinimo) + valorMinimo);
+}
+exports.defineVisibleValue = defineVisibleValue;
+function definePostionByValue(nuevoValor, ancho, valorMaximo, valorMinimo) {
+    return ((nuevoValor - valorMinimo) / (valorMaximo - valorMinimo)) * (ancho);
+}
+exports.definePostionByValue = definePostionByValue;

package/dist/cjs/components/Slider/types.d.ts

@@ -0,0 +1,14 @@
+export interface SliderPropsType {
+  minimumValue: number;
+  maximumValue: number;
+  onChange: (newValue: number) => void;
+  initialValue?: number;
+  value?: number;
+  showValueInsideButton?: boolean;
+  editableValueInsideButton?: boolean;
+  height?: number;
+  width?: number;
+  sufix?: string;
+  prefix?: string;
+  disabled?: boolean;
+}

package/dist/cjs/hooks/useIntersectionObserver.d.ts

@@ -0,0 +1,9 @@
+import { RefObject } from "react";
+/**
+ * Hook to observe an element's intersection
+ * @param ref ref to the element to observe
+ * @param options intersection observer options
+ * @returns a boolean indicating if the element is intersecting
+ */
+declare function useIntersectionObserver(ref: RefObject<Element>, options?: IntersectionObserverInit | undefined): boolean;
+export default useIntersectionObserver;

package/dist/cjs/hooks/useIntersectionObserver.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/**
+ * Hook to observe an element's intersection
+ * @param ref ref to the element to observe
+ * @param options intersection observer options
+ * @returns a boolean indicating if the element is intersecting
+ */
+function useIntersectionObserver(ref, options) {
+    const [isIntersecting, setIsIntersecting] = (0, react_1.useState)(false);
+    const observer = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        if (observer.current)
+            observer.current.disconnect();
+        observer.current = new IntersectionObserver(([entry]) => {
+            setIsIntersecting(entry.isIntersecting);
+        }, options);
+        if (ref.current)
+            observer.current.observe(ref.current);
+        return () => {
+            if (observer.current)
+                observer.current.disconnect();
+        };
+    }, [ref, options]);
+    return isIntersecting;
+}
+exports.default = useIntersectionObserver;

package/dist/cjs/hooks/useOutsideClick.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function useOutsideClick(elementRef: React.MutableRefObject<HTMLElement | null>, onOutsideClickAction: Function, elementsRefsExceptions?: React.MutableRefObject<HTMLElement | null>[]): void;
+export default useOutsideClick;

package/dist/cjs/hooks/useOutsideClick.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+function useOutsideClick(elementRef, onOutsideClickAction, elementsRefsExceptions = []) {
+    (0, react_1.useEffect)(() => {
+        function handleClickOutside(event) {
+            if (elementRef.current &&
+                !elementRef.current.contains(event.target) &&
+                elementsRefsExceptions.every((elementRefException) => elementRefException.current !== event.target)) {
+                onOutsideClickAction();
+            }
+        }
+        document.addEventListener("mousedown", handleClickOutside);
+        return () => {
+            document.removeEventListener("mousedown", handleClickOutside);
+        };
+    }, [elementRef, onOutsideClickAction, elementsRefsExceptions]);
+}
+exports.default = useOutsideClick;

package/dist/cjs/hooks/useResizeObserver.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+/**
+ * @returns Array [elementWidth, elementHeight], that represent the current
+ * values of width and height of elementRef
+ */
+declare function useResizeObserver(elementRef: React.MutableRefObject<HTMLElement | null>): number[];
+export default useResizeObserver;

package/dist/cjs/hooks/useResizeObserver.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/**
+ * @returns Array [elementWidth, elementHeight], that represent the current
+ * values of width and height of elementRef
+ */
+function useResizeObserver(elementRef) {
+    const [elementWidth, setElementWidth] = (0, react_1.useState)(0);
+    const [elementHeight, setElementHeight] = (0, react_1.useState)(0);
+    const observer = (0, react_1.useRef)(new ResizeObserver((entries) => {
+        const { width, height } = entries[0].contentRect;
+        setElementWidth(width);
+        setElementHeight(height);
+    }));
+    (0, react_1.useEffect)(() => {
+        if (elementRef.current !== null) {
+            observer.current.observe(elementRef.current);
+        }
+        const observerCurrentForCleanUp = observer.current;
+        const elementRefCurrentForCleanUp = elementRef.current;
+        return () => {
+            if (elementRefCurrentForCleanUp !== null) {
+                observerCurrentForCleanUp.unobserve(elementRefCurrentForCleanUp);
+            }
+        };
+    }, [elementRef, observer]);
+    return [elementWidth, elementHeight];
+}
+exports.default = useResizeObserver;

package/dist/cjs/hooks/useWindowsSize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @returns Array [ancho, alto], de dichos valores refieren
+ * los valores de window.innerWidth y window.innerHeight
+ */
+declare function useWindowSize(): [number, number];
+export default useWindowSize;

package/dist/cjs/hooks/useWindowsSize.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/**
+ * @returns Array [ancho, alto], de dichos valores refieren
+ * los valores de window.innerWidth y window.innerHeight
+ */
+function useWindowSize() {
+    const [size, setSize] = (0, react_1.useState)([0, 0]);
+    (0, react_1.useLayoutEffect)(() => {
+        function updateSize() {
+            setSize([window.innerWidth, window.innerHeight]);
+        }
+        window.addEventListener("resize", updateSize);
+        updateSize();
+        return () => window.removeEventListener("resize", updateSize);
+    }, []);
+    return size;
+}
+exports.default = useWindowSize;

package/dist/cjs/index.css

@@ -0,0 +1,79 @@
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu",
+    "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  color: black;
+}
+
+body p {
+  line-height: normal;
+  margin: 0;
+}
+
+code {
+  font-family: source-code-pro, Menlo, Monaco, Consolas, "Courier New", monospace;
+}
+
+:root {
+  --primary-color: #ec6321;
+  --secondary-color: #46ba0d;
+  --green-palette-one: #7bce51;
+  --green-palette-two: #52ac25;
+  --green-palette-three: #3a8117;
+  --green-palette-four: #27580f;
+  --green-palette-five: #1b3a0c;
+  --light-gray: #959595;
+  --medium-gray: #787878;
+}
+
+input[type="checkbox"] {
+  /* Add if not using autoprefixer */
+  -webkit-appearance: none;
+  /* Remove most all native input styles */
+  appearance: none;
+  /* For iOS < 15 */
+  background-color: white;
+  /* Not removed via appearance */
+  margin: 0;
+
+  font: inherit;
+  color: dimgray;
+  min-width: 1.15em;
+  width: 1.15em;
+  height: 1.15em;
+  border: 0.15em solid dimgray;
+  border-radius: 0.15em;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+}
+
+input[type="checkbox"]::before {
+  content: "";
+  width: 0.65em;
+  height: 0.65em;
+  clip-path: polygon(14% 44%, 0 65%, 50% 100%, 100% 16%, 80% 0%, 43% 62%);
+  transform: scale(0);
+  transform-origin: bottom left;
+  transition: 120ms transform ease-in-out;
+  box-shadow: inset 1em 1em var(--primary-color);
+  /* Windows High Contrast Mode */
+  background-color: CanvasText;
+}
+
+input[type="checkbox"]:checked::before {
+  transform: scale(1);
+}
+
+input[type="checkbox"]:focus {
+  outline: max(2px, 0.08em) solid rgb(145, 145, 145);
+  outline-offset: max(2px, 0.08em);
+}
+
+input[type="checkbox"]:disabled {
+  color: rgb(165, 165, 165);
+  cursor: not-allowed;
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,20 @@
+import Multicalendar from "./components/Multicalendar/Multicalendar";
+import SideBar from "./components/SideBar/SideBar";
+import SearchBar from "./components/SearchBar/SearchBar";
+import Modal from "./components/Modal/Modal";
+import PopUp from "./components/PopUp/PopUp";
+import ProgressBar from "./components/ProgressBar/ProgressBar";
+import ParallelSelectionList from "./components/ParallelSelectionList/ParallelSelectionList";
+import Slider from "./components/Slider/Slider";
+import MultipleJoinedButtonsBar from "./components/MultipleJoinedButtonsBar/MultipleJoinedButtonsBar";
+import ExportToExcelButton from "./components/ExportToExcelButton/ExportToExcelButton";
+import InputBoxWithConfirmation from "./components/InputBoxWithConfirmation/InputBoxWithConfirmation";
+import CalendarDatePicker from "./components/CalendarDatePicker/CalendarDatePicker";
+import IntegerControl from "./components/IntegerControl/IntegerControl";
+import BubbleMenu from "./components/BubbleMenu/BubbleMenu";
+import LabeledInput from "./components/LabeledInput/LabeledInput";
+import ScreenSteps from "./components/ScreenSteps/ScreenSteps";
+import ScrollSnapGallery from "./components/ScrollSnapGallery/ScrollSnapGallery";
+import { setMulticalendarScrollTopPosition, setMulticalendarScrollLeftPosition, eraseMulticalendarScrollLeftPosition, eraseMulticalendarScrollTopPosition } from "./Services/MulticalendarStatesAndSettings";
+export type { ExportToExcelButtonPropsType } from "./components/ExportToExcelButton/types";
+export { Multicalendar, setMulticalendarScrollTopPosition, setMulticalendarScrollLeftPosition, eraseMulticalendarScrollLeftPosition, eraseMulticalendarScrollTopPosition, SideBar, SearchBar, Modal, PopUp, ProgressBar, ParallelSelectionList, Slider, MultipleJoinedButtonsBar, ExportToExcelButton, CalendarDatePicker, InputBoxWithConfirmation, IntegerControl, BubbleMenu, LabeledInput, ScreenSteps, ScrollSnapGallery };

package/dist/cjs/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScrollSnapGallery = exports.ScreenSteps = exports.LabeledInput = exports.BubbleMenu = exports.IntegerControl = exports.InputBoxWithConfirmation = exports.CalendarDatePicker = exports.ExportToExcelButton = exports.MultipleJoinedButtonsBar = exports.Slider = exports.ParallelSelectionList = exports.ProgressBar = exports.PopUp = exports.Modal = exports.SearchBar = exports.SideBar = exports.eraseMulticalendarScrollTopPosition = exports.eraseMulticalendarScrollLeftPosition = exports.setMulticalendarScrollLeftPosition = exports.setMulticalendarScrollTopPosition = exports.Multicalendar = void 0;
+const Multicalendar_1 = __importDefault(require("./components/Multicalendar/Multicalendar"));
+exports.Multicalendar = Multicalendar_1.default;
+const SideBar_1 = __importDefault(require("./components/SideBar/SideBar"));
+exports.SideBar = SideBar_1.default;
+const SearchBar_1 = __importDefault(require("./components/SearchBar/SearchBar"));
+exports.SearchBar = SearchBar_1.default;
+const Modal_1 = __importDefault(require("./components/Modal/Modal"));
+exports.Modal = Modal_1.default;
+const PopUp_1 = __importDefault(require("./components/PopUp/PopUp"));
+exports.PopUp = PopUp_1.default;
+const ProgressBar_1 = __importDefault(require("./components/ProgressBar/ProgressBar"));
+exports.ProgressBar = ProgressBar_1.default;
+const ParallelSelectionList_1 = __importDefault(require("./components/ParallelSelectionList/ParallelSelectionList"));
+exports.ParallelSelectionList = ParallelSelectionList_1.default;
+const Slider_1 = __importDefault(require("./components/Slider/Slider"));
+exports.Slider = Slider_1.default;
+const MultipleJoinedButtonsBar_1 = __importDefault(require("./components/MultipleJoinedButtonsBar/MultipleJoinedButtonsBar"));
+exports.MultipleJoinedButtonsBar = MultipleJoinedButtonsBar_1.default;
+const ExportToExcelButton_1 = __importDefault(require("./components/ExportToExcelButton/ExportToExcelButton"));
+exports.ExportToExcelButton = ExportToExcelButton_1.default;
+const InputBoxWithConfirmation_1 = __importDefault(require("./components/InputBoxWithConfirmation/InputBoxWithConfirmation"));
+exports.InputBoxWithConfirmation = InputBoxWithConfirmation_1.default;
+const CalendarDatePicker_1 = __importDefault(require("./components/CalendarDatePicker/CalendarDatePicker"));
+exports.CalendarDatePicker = CalendarDatePicker_1.default;
+const IntegerControl_1 = __importDefault(require("./components/IntegerControl/IntegerControl"));
+exports.IntegerControl = IntegerControl_1.default;
+const BubbleMenu_1 = __importDefault(require("./components/BubbleMenu/BubbleMenu"));
+exports.BubbleMenu = BubbleMenu_1.default;
+const LabeledInput_1 = __importDefault(require("./components/LabeledInput/LabeledInput"));
+exports.LabeledInput = LabeledInput_1.default;
+const ScreenSteps_1 = __importDefault(require("./components/ScreenSteps/ScreenSteps"));
+exports.ScreenSteps = ScreenSteps_1.default;
+const ScrollSnapGallery_1 = __importDefault(require("./components/ScrollSnapGallery/ScrollSnapGallery"));
+exports.ScrollSnapGallery = ScrollSnapGallery_1.default;
+const MulticalendarStatesAndSettings_1 = require("./Services/MulticalendarStatesAndSettings");
+Object.defineProperty(exports, "setMulticalendarScrollTopPosition", { enumerable: true, get: function () { return MulticalendarStatesAndSettings_1.setMulticalendarScrollTopPosition; } });
+Object.defineProperty(exports, "setMulticalendarScrollLeftPosition", { enumerable: true, get: function () { return MulticalendarStatesAndSettings_1.setMulticalendarScrollLeftPosition; } });
+Object.defineProperty(exports, "eraseMulticalendarScrollLeftPosition", { enumerable: true, get: function () { return MulticalendarStatesAndSettings_1.eraseMulticalendarScrollLeftPosition; } });
+Object.defineProperty(exports, "eraseMulticalendarScrollTopPosition", { enumerable: true, get: function () { return MulticalendarStatesAndSettings_1.eraseMulticalendarScrollTopPosition; } });

package/dist/cjs/languages/en-EN.d.ts

@@ -0,0 +1,3 @@
+import { languageType } from "./types";
+declare const spanish: languageType;
+export default spanish;