stargazer-ui 1.0.1 → 1.0.3

package/dist/BaseTypes.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+export type BaseAnchorType = React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;
+export type BaseButtonType = React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+export type BaseDivType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+export type BaseFormType = React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>;
+export type BaseHeadingType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+export type BaseInputType = React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+export type BaseHrType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLHRElement>, HTMLHRElement>;
+export type BaseLabelType = React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+export type BaseLItemType = React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>;
+export type BaseParagraphType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
+export type BaseSelectType = React.DetailedHTMLProps<React.SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>;
+export type BaseSmallType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+export type BaseSpanType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
+export type BaseUListType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>;

package/dist/BaseTypes.js

@@ -0,0 +1 @@
+

package/dist/Button/index.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { BaseButtonType } from "../BaseTypes";
+export type ButtonType = {
+    children: typeof React.Children;
+    variant?: string;
+    className?: string;
+} & BaseButtonType;
+declare const Button: React.ForwardRefExoticComponent<Omit<ButtonType, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export default Button;

package/dist/Button/index.js

@@ -0,0 +1,6 @@
+import { jsx as e } from "react/jsx-runtime";
+import { forwardRef as f } from "react";
+const s = f(({ children: o, variant: r = "primary", className: t, ...n }, u) => /* @__PURE__ */ e("button", { ref: u, type: "button", className: `sg-button sg-button-${r}${t == null ? "" : " " + t}`, ...n, children: o }));
+export {
+  s as default
+};

package/dist/Card/index.d.ts

@@ -0,0 +1,92 @@
+import React from "react";
+import { BaseDivType, BaseHeadingType, BaseSpanType, BaseParagraphType } from "../BaseTypes";
+export type CardType = {
+    children: typeof React.Children;
+    className?: string;
+} & BaseDivType;
+export type CardHeaderPossible = BaseDivType | BaseSpanType | BaseHeadingType;
+export type CardHeaderType = {
+    children: typeof React.Children;
+    className?: string;
+    as?: React.ElementType;
+} & CardHeaderPossible;
+export type CardBodyType = {
+    children: typeof React.Children;
+    className?: string;
+} & BaseDivType;
+export type CardTextType = {
+    children: typeof React.Children;
+    className?: string;
+} & BaseParagraphType;
+export type CardFooterType = {
+    children: typeof React.Children;
+    className?: string;
+} & BaseDivType;
+declare const _default: React.ForwardRefExoticComponent<Omit<CardType, "ref"> & React.RefAttributes<HTMLDivElement>> & {
+    Header: React.ForwardRefExoticComponent<(Omit<{
+        children: {
+            map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Exclude<T, boolean | null | undefined>[];
+            forEach<C_1>(children: C_1 | readonly C_1[], fn: (child: C_1, index: number) => void): void;
+            count(children: any): number;
+            only<C_2>(children: C_2): C_2 extends any[] ? never : C_2;
+            toArray(children: React.ReactNode | React.ReactNode[]): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | React.ReactPortal)[];
+        };
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "ref"> | Omit<{
+        children: {
+            map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Exclude<T, boolean | null | undefined>[];
+            forEach<C_1>(children: C_1 | readonly C_1[], fn: (child: C_1, index: number) => void): void;
+            count(children: any): number;
+            only<C_2>(children: C_2): C_2 extends any[] ? never : C_2;
+            toArray(children: React.ReactNode | React.ReactNode[]): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | React.ReactPortal)[];
+        };
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLHeadingElement> & React.HTMLAttributes<HTMLHeadingElement>, "ref"> | Omit<{
+        children: {
+            map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Exclude<T, boolean | null | undefined>[];
+            forEach<C_1>(children: C_1 | readonly C_1[], fn: (child: C_1, index: number) => void): void;
+            count(children: any): number;
+            only<C_2>(children: C_2): C_2 extends any[] ? never : C_2;
+            toArray(children: React.ReactNode | React.ReactNode[]): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | React.ReactPortal)[];
+        };
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLSpanElement> & React.HTMLAttributes<HTMLSpanElement>, "ref">) & React.RefAttributes<HTMLDivElement | HTMLHeadingElement | HTMLSpanElement>>;
+    Body: React.ForwardRefExoticComponent<Omit<CardBodyType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<(Omit<{
+        children: {
+            map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Exclude<T, boolean | null | undefined>[];
+            forEach<C_1>(children: C_1 | readonly C_1[], fn: (child: C_1, index: number) => void): void;
+            count(children: any): number;
+            only<C_2>(children: C_2): C_2 extends any[] ? never : C_2;
+            toArray(children: React.ReactNode | React.ReactNode[]): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | React.ReactPortal)[];
+        };
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "ref"> | Omit<{
+        children: {
+            map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Exclude<T, boolean | null | undefined>[];
+            forEach<C_1>(children: C_1 | readonly C_1[], fn: (child: C_1, index: number) => void): void;
+            count(children: any): number;
+            only<C_2>(children: C_2): C_2 extends any[] ? never : C_2;
+            toArray(children: React.ReactNode | React.ReactNode[]): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | React.ReactPortal)[];
+        };
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLHeadingElement> & React.HTMLAttributes<HTMLHeadingElement>, "ref"> | Omit<{
+        children: {
+            map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Exclude<T, boolean | null | undefined>[];
+            forEach<C_1>(children: C_1 | readonly C_1[], fn: (child: C_1, index: number) => void): void;
+            count(children: any): number;
+            only<C_2>(children: C_2): C_2 extends any[] ? never : C_2;
+            toArray(children: React.ReactNode | React.ReactNode[]): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | React.ReactPortal)[];
+        };
+        className?: string | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    } & React.ClassAttributes<HTMLSpanElement> & React.HTMLAttributes<HTMLSpanElement>, "ref">) & React.RefAttributes<HTMLHeadingElement>>;
+    Text: React.ForwardRefExoticComponent<Omit<CardTextType, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+    Footer: React.ForwardRefExoticComponent<Omit<CardFooterType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+export default _default;

package/dist/Card/index.js

@@ -0,0 +1,18 @@
+import { jsx as a } from "react/jsx-runtime";
+import { forwardRef as d } from "react";
+const h = d(({ children: e, className: t, ...r }, s) => /* @__PURE__ */ a("div", { ref: s, className: "sg-card " + t, ...r, children: e })), l = d(({ as: e = "div", className: t, children: r, ...s }, o) => {
+  let n = ["div", "span", "h1", "h2", "h3", "h4", "h5", "h6"].find((c) => c === e) ? e : "div";
+  return /* @__PURE__ */ a(n, { ref: o, className: `sg-card-header ${t}`, ...s, children: r });
+}), m = d(({ as: e = "h5", className: t, children: r, ...s }, o) => {
+  let n = ["h1", "h2", "h3", "h4", "h5", "h6"].find((c) => c === e) ? e : "h5";
+  return /* @__PURE__ */ a(n, { ref: o, className: t, ...s, children: r });
+}), v = d(({ children: e, className: t, ...r }, s) => /* @__PURE__ */ a("div", { ref: s, className: `sg-card-body ${t}`, ...r, children: e })), f = d(({ children: e, className: t, ...r }, s) => /* @__PURE__ */ a("p", { ref: s, className: `sg-card-text ${t}`, ...r, children: e })), p = d(({ children: e, className: t, ...r }, s) => /* @__PURE__ */ a("div", { ref: s, className: `sg-card-footer ${t}`, ...r, children: e })), x = Object.assign(h, {
+  Header: l,
+  Body: v,
+  Title: m,
+  Text: f,
+  Footer: p
+});
+export {
+  x as default
+};

package/dist/CloseButton/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { BaseButtonType } from "../BaseTypes";
+export type CloseButtonType = {
+    className?: string;
+    variant?: boolean;
+} & BaseButtonType;
+declare const CloseButton: import("react").ForwardRefExoticComponent<Omit<CloseButtonType, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export default CloseButton;

package/dist/CloseButton/index.js

@@ -0,0 +1,6 @@
+import { jsx as s } from "react/jsx-runtime";
+import { forwardRef as a } from "react";
+const c = a(({ className: e, variant: o = !1, ...l }, t) => /* @__PURE__ */ s("button", { ref: t, className: `sg-button-close${o ? " sg-button-close-white" : ""} ${e}`, ...l, children: /* @__PURE__ */ s("span", { className: "sg-close-visually-hidden-label", children: "Close" }) }));
+export {
+  c as default
+};

package/dist/Dropdown/index.d.ts

@@ -0,0 +1,108 @@
+import React from "react";
+import { BaseDivType, BaseAnchorType, BaseButtonType, BaseUListType, BaseHrType } from "../BaseTypes";
+export type DropdownContextType = {
+    align: string;
+    drop: string;
+    showInternal: boolean;
+    handleToggle: Function;
+    placement: string;
+    directionClasses?: {
+        down?: string;
+        'down-centered'?: string;
+        up?: string;
+        'up-centered'?: string;
+        end?: string;
+        start?: string;
+    };
+    controlId: string;
+    activeDescendant: {
+        case: string;
+    };
+    setActiveDescendant: React.Dispatch<React.SetStateAction<{
+        case: string;
+    }>>;
+};
+export declare const DropdownContext: React.Context<DropdownContextType | null>;
+export declare const useDropdownContext: () => DropdownContextType;
+export type DropdownType = {
+    children: React.ReactNode;
+    className?: string;
+    onSelect?: Function;
+    onToggle?: Function;
+    controlId: string;
+    drop?: string;
+    align?: string;
+    autoClose?: boolean;
+    show?: boolean;
+} & BaseDivType;
+export type DropdownToggleType = {
+    children: React.ReactNode;
+    className?: string;
+    navDropdown?: boolean;
+    as?: React.ElementType;
+    variant?: string;
+} & (BaseAnchorType | BaseButtonType);
+export declare const Toggle: React.ForwardRefExoticComponent<(Omit<{
+    children: React.ReactNode;
+    className?: string | undefined;
+    navDropdown?: boolean | undefined;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    variant?: string | undefined;
+} & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+    children: React.ReactNode;
+    className?: string | undefined;
+    navDropdown?: boolean | undefined;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    variant?: string | undefined;
+} & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+export type DropdownMenuType = {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties | undefined;
+} & BaseUListType;
+export declare const Menu: React.ForwardRefExoticComponent<Omit<DropdownMenuType, "ref"> & React.RefAttributes<HTMLUListElement>>;
+export type DropdownItemType = {
+    children: React.ReactNode;
+    as?: React.ElementType;
+    className?: string;
+} & (BaseAnchorType | BaseButtonType);
+export declare const Item: React.ForwardRefExoticComponent<(Omit<{
+    children: React.ReactNode;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    className?: string | undefined;
+} & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+    children: React.ReactNode;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+    className?: string | undefined;
+} & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+export type DropdownDividerType = {
+    className?: string;
+} & BaseHrType;
+export declare const Divider: React.ForwardRefExoticComponent<Omit<DropdownDividerType, "ref"> & React.RefAttributes<HTMLHRElement>>;
+declare const _default: React.ForwardRefExoticComponent<Omit<DropdownType, "ref"> & React.RefAttributes<HTMLDivElement>> & {
+    Toggle: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        navDropdown?: boolean | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        variant?: string | undefined;
+    } & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        className?: string | undefined;
+        navDropdown?: boolean | undefined;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        variant?: string | undefined;
+    } & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+    Menu: React.ForwardRefExoticComponent<Omit<DropdownMenuType, "ref"> & React.RefAttributes<HTMLUListElement>>;
+    Item: React.ForwardRefExoticComponent<(Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+    } & React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement>, "ref"> | Omit<{
+        children: React.ReactNode;
+        as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+        className?: string | undefined;
+    } & React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>, "ref">) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+    Divider: React.ForwardRefExoticComponent<Omit<DropdownDividerType, "ref"> & React.RefAttributes<HTMLHRElement>>;
+};
+export default _default;

package/dist/Dropdown/index.js

@@ -0,0 +1,204 @@
+import { jsx as v } from "react/jsx-runtime";
+import { createContext as D, forwardRef as E, useState as y, useMemo as $, useEffect as C, useLayoutEffect as A, useContext as P } from "react";
+const L = (d, o, r = !1) => {
+  const u = r ? "top-end" : "top-start", m = r ? "top-start" : "top-end", i = r ? "bottom-end" : "bottom-start", h = r ? "bottom-start" : "bottom-end", g = r ? "right-start" : "left-start", a = r ? "right-end" : "left-end", w = r ? "left-start" : "right-start", l = r ? "left-end" : "right-end";
+  let n = d ? h : i;
+  return o === "up" ? n = d ? m : u : o === "end" ? n = d ? l : w : o === "start" ? n = d ? a : g : o === "down-centered" ? n = "bottom" : o === "up-centered" && (n = "top"), n;
+}, k = (d, o = "") => {
+  let r = d.target, u = !0, m = !1;
+  for (; u; )
+    r.id != o + "-menu" ? r = r.parentElement : (m = !0, u = !1), r.id === "root" && (u = !1, m = !1);
+  return m;
+}, I = D(null), M = ({ children: d, value: o }) => /* @__PURE__ */ v(I.Provider, { value: o, children: d }), x = () => {
+  const d = P(I);
+  if (!d)
+    throw new Error(
+      "useDropdownContext has to be used within DropdownContextProvider!"
+    );
+  return d;
+}, O = E(({
+  children: d,
+  className: o,
+  onSelect: r,
+  onToggle: u,
+  controlId: m,
+  drop: i = "down",
+  align: h = "start",
+  autoClose: g = !0,
+  show: a = "default",
+  ...w
+}, l) => {
+  const [n, e] = y(a && !1), [f, b] = y({ case: "" }), c = (B) => {
+    B.stopPropagation(), e((S) => !S);
+  }, s = L(h === "end", i), p = $(() => ({
+    align: h,
+    drop: i,
+    showInternal: a != "default" && u ? a : n,
+    handleToggle: a != "default" && u ? u : c,
+    placement: s,
+    directionClasses: {
+      down: "dropdown",
+      "down-centered": "dropdown-center",
+      up: "dropup",
+      "up-centered": "dropup-center dropup",
+      end: "dropend",
+      start: "dropstart"
+    },
+    controlId: m,
+    activeDescendant: f,
+    setActiveDescendant: b
+  }), [h, i, a, n, u, s, m, f, b]);
+  return /* @__PURE__ */ v("div", { id: m + "-wrapper", ref: l, className: `sg-dropdown${o ? " " + o : ""}`, ...w, children: /* @__PURE__ */ v(M, { value: p, children: d }) });
+}), q = E(({ children: d, className: o, navDropdown: r = !1, as: u = "button", variant: m = "primary", ...i }, h) => {
+  const { controlId: g, handleToggle: a, setActiveDescendant: w, showInternal: l } = x(), n = u, e = (t) => {
+    let s = !1;
+    switch (console.log(t.key), t.key) {
+      case "ArrowDown":
+        s = !0, l ? w((p) => ({ ...p, case: "next" })) : (a(t), w((p) => ({ ...p, case: "first" })));
+        break;
+      case "ArrowUp":
+        s = !0, l ? w((p) => ({ ...p, case: "previous" })) : (a(t), w((p) => ({ ...p, case: "last" })));
+        break;
+      case "Home":
+        s = !0, l && w((p) => ({ ...p, case: "first" }));
+        break;
+      case "End":
+        s = !0, l && w((p) => ({ ...p, case: "last" }));
+        break;
+      case "Tab":
+        l && a(t);
+        break;
+      case "Escape":
+        s = !0, l && a(t);
+        break;
+      case "Enter":
+      case " ":
+        if (l) {
+          s = !0, document.querySelector(".sg-dropdown-item-visual-focus").click(), a(t);
+          break;
+        } else {
+          w((p) => ({ ...p, case: "first" }));
+          break;
+        }
+    }
+    s && (t.stopPropagation(), t.preventDefault());
+  }, f = (t) => {
+    if (l && t.target.id !== g) {
+      if (!k(t, g))
+        a(t);
+      else if (k(t, g)) {
+        a(t);
+        const s = document.getElementById(g);
+        s == null || s.focus();
+      }
+    }
+  };
+  C(() => {
+    const t = document.getElementById(g);
+    return t.addEventListener("keydown", e, !0), document.addEventListener("mouseup", f, !0), function() {
+      t.removeEventListener("keydown", e, !0), document.removeEventListener("mouseup", f, !0);
+    };
+  }, [e, g]);
+  const b = (t) => {
+    a(t), l || w((s) => ({ ...s, case: "first" }));
+  };
+  let c = `sg-button sg-button${m ? "-" + m : "-primary"} sg-dropdown-toggle${o ? " " + o : ""}`;
+  return (n === "a" || r) && (c = `sg-nav-dropdown-toggle sg-dropdown-toggle${o ? " " + o : ""}`), /* @__PURE__ */ v(
+    n,
+    {
+      tabIndex: "0",
+      type: "button",
+      "aria-haspopup": "true",
+      "aria-controls": g + "-menu",
+      "aria-expanded": l,
+      id: g,
+      ref: h,
+      className: c,
+      onClick: (t) => b(t),
+      ...i,
+      children: d
+    }
+  );
+}), j = E(({ children: d, className: o, style: r = {}, ...u }, m) => {
+  const { controlId: i, showInternal: h, activeDescendant: g } = x(), [a, w] = y(r);
+  A(() => {
+    if (h) {
+      const n = document.getElementById(i + "-menu");
+      let e = {};
+      n.getBoundingClientRect().right > window.innerWidth ? e = { ...e, right: 0 } : n.getBoundingClientRect().left < 0 ? e = { ...e, left: 0 } : n.getBoundingClientRect().top < 0 ? e = { ...e, top: 0 } : n.getBoundingClientRect().bottom > window.innerHeight && (e = { ...e, bottom: 0 }), w((f) => ({ ...f, ...e }));
+    }
+  }, [h]), C(() => {
+    if (h) {
+      const n = document.getElementById(i + "-menu"), e = document.getElementById(i + "-menu").children, f = e.length - 1, b = document.querySelector(".sg-dropdown-item-visual-focus");
+      let c = 0, t = e[0].children[0];
+      if (b != null) {
+        b.classList.remove("sg-dropdown-item-visual-focus");
+        for (let s = 0; s < e.length; s++)
+          if (e[s] === b.parentElement) {
+            c = s;
+            break;
+          }
+      }
+      switch (g.case) {
+        case "first":
+          t = e[0].children[0], c = 0;
+          break;
+        case "last":
+          t = e[f].children[0], c = f;
+          break;
+        case "next":
+          c = c === f ? 0 : c + 1, t = e[c].children[0];
+          break;
+        case "previous":
+          c = c === 0 ? f : c - 1, t = e[c].children[0];
+          break;
+      }
+      n.setAttribute("aria-activedescendant", t.id), e[c].children[0].classList.add("sg-dropdown-item-visual-focus");
+    } else
+      document.getElementById(i + "-menu").setAttribute("aria-activedescendant", "");
+  }, [i, h, g]);
+  const l = (n) => {
+    var c;
+    const e = n.target;
+    let f = e.classList.contains("sg-dropdown-item-visual-focus");
+    const b = document.getElementById(i + "-menu");
+    f || ((c = document.querySelector(".sg-dropdown-item-visual-focus")) == null || c.classList.remove("sg-dropdown-item-visual-focus"), b.setAttribute("aria-activedescendant", ""), e.classList.add("sg-dropdown-item-visual-focus"), b.setAttribute("aria-activedescendant", e.id));
+  };
+  return C(() => {
+    const n = document.getElementById(i + "-menu");
+    for (let e of n.children)
+      e.addEventListener("mouseover", l, !0);
+    return function() {
+      for (let f of n.children)
+        f.removeEventListener("mouseover", l, !0);
+    };
+  }, []), /* @__PURE__ */ v(
+    "ul",
+    {
+      id: i + "-menu",
+      role: "menu",
+      tabIndex: -1,
+      "aria-labelledby": i,
+      ref: m,
+      className: `sg-dropdown-list${o ? " " + o : ""}${h ? " show" : ""}`,
+      style: a,
+      ...u,
+      children: d
+    }
+  );
+}), H = E(({ children: d, as: o = "button", className: r, ...u }, m) => /* @__PURE__ */ v("li", { role: "none", children: /* @__PURE__ */ v(o, { ref: m, role: "menuitem", tabIndex: "-1", className: `sg-dropdown-item${r ? " " + r : ""}`, ...u, children: d }) })), V = E(({ className: d = "", ...o }, r) => /* @__PURE__ */ v("hr", { ref: r, className: `.sg-dropdown-divider${d}`, ...o })), K = Object.assign(O, {
+  Toggle: q,
+  Menu: j,
+  Item: H,
+  //Text: Text,
+  Divider: V
+});
+export {
+  V as Divider,
+  I as DropdownContext,
+  H as Item,
+  j as Menu,
+  q as Toggle,
+  K as default,
+  x as useDropdownContext
+};

package/dist/FloatingLabel/index.js

@@ -0,0 +1,13 @@
+import { jsx as r, jsxs as n } from "react/jsx-runtime";
+import { forwardRef as s, useMemo as i } from "react";
+import { FormContext as f } from "../Form/index.js";
+const u = s(({ children: e, label: t, controlId: l, ...a }, m) => {
+  const o = i(() => ({ controlId: l }));
+  return /* @__PURE__ */ r(f.Provider, { value: o, children: /* @__PURE__ */ n("div", { className: "sg-form-floating", children: [
+    e,
+    /* @__PURE__ */ r("label", { ref: m, htmlFor: o.controlId, className: "sg-form-floating-label", ...a, children: t })
+  ] }) });
+});
+export {
+  u as default
+};

package/dist/Form/index.d.ts

@@ -0,0 +1,61 @@
+import React from "react";
+import { BaseDivType, BaseFormType, BaseInputType, BaseLabelType, BaseSelectType, BaseSmallType } from "../BaseTypes";
+export type FormContextType = {
+    controlId: string;
+};
+export declare const FormContext: React.Context<FormContextType | null>;
+export declare const useFormContext: () => FormContextType;
+export type FormType = {
+    children: React.ReactNode;
+} & BaseFormType;
+export type FormControlType = {
+    as?: React.ElementType;
+    className?: string;
+    plaintext?: boolean;
+    id?: string;
+    type?: string;
+    autoFocus?: boolean;
+} & BaseInputType;
+export type FormSelectType = {
+    children: React.ReactNode;
+    className?: string;
+    id?: string;
+} & BaseSelectType;
+export type FormGroupType = {
+    children: React.ReactNode;
+    className?: string;
+    controlId: string;
+} & BaseDivType;
+export type FormLabelType = {
+    children: React.ReactNode;
+    className?: string;
+    htmlFor?: string;
+} & BaseLabelType;
+export type FormCheckType = {
+    classNameContainer?: string;
+    containerRef?: React.LegacyRef<HTMLDivElement>;
+    containerId?: string;
+    style?: React.CSSProperties;
+    classNameLabel?: string;
+    labelRef?: React.LegacyRef<HTMLLabelElement>;
+    label?: string;
+    labelId?: string;
+    className?: string;
+    type?: string;
+    controlId?: string;
+    reverse?: boolean;
+    checkStyle?: React.CSSProperties;
+} & BaseInputType;
+export type FormTextType = {
+    children: React.ReactNode;
+    className?: string;
+} & BaseSmallType;
+declare const _default: React.ForwardRefExoticComponent<Omit<FormType, "ref"> & React.RefAttributes<HTMLFormElement>> & {
+    Control: React.ForwardRefExoticComponent<Omit<FormControlType, "ref"> & React.RefAttributes<HTMLInputElement>>;
+    Select: React.ForwardRefExoticComponent<Omit<FormSelectType, "ref"> & React.RefAttributes<HTMLSelectElement>>;
+    Group: React.ForwardRefExoticComponent<Omit<FormGroupType, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Label: React.ForwardRefExoticComponent<Omit<FormLabelType, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+    Check: React.ForwardRefExoticComponent<Omit<FormCheckType, "ref"> & React.RefAttributes<HTMLInputElement>>;
+    Text: React.ForwardRefExoticComponent<Omit<FormTextType, "ref"> & React.RefAttributes<HTMLElement>>;
+};
+export default _default;

package/dist/Form/index.js

@@ -0,0 +1,62 @@
+import { jsx as n, jsxs as $, Fragment as k } from "react/jsx-runtime";
+import { createContext as b, forwardRef as l, useMemo as j, useContext as I } from "react";
+const w = b(null), H = ({ children: e, value: t }) => /* @__PURE__ */ n(w.Provider, { value: t, children: e }), g = () => {
+  const e = I(w);
+  if (!e)
+    throw new Error(
+      "useFormContext has to be used within a FormContextProvider!"
+    );
+  return e;
+}, P = l(({ children: e, ...t }, o) => /* @__PURE__ */ n("form", { ref: o, ...t, children: e })), y = l(({ as: e = "input", className: t = "", plaintext: o = !1, id: c = "", type: r = "text", autoFocus: s = !1, ...m }, u) => {
+  let i = e;
+  const { controlId: d } = g();
+  let x = d || c, f = (o ? "sg-form-control-plaintext" : "sg-form-control") + (t != "" ? " " + t : "") + (r == "color" ? " sg-form-control-color" : "");
+  return /* @__PURE__ */ n(i, { autoFocus: s, ref: u, id: x, type: r, className: f, ...m });
+}), E = l(({ children: e, className: t, id: o, ...c }, r) => {
+  const { controlId: s } = g();
+  let m = s || o;
+  return /* @__PURE__ */ n("select", { ref: r, className: `sg-form-select${t ? " " + t : ""}`, id: m, ...c, children: e });
+}), G = l(({ children: e, className: t, controlId: o, ...c }, r) => {
+  const s = j(() => ({ controlId: o }), [o]);
+  return /* @__PURE__ */ n("div", { ref: r, className: `sg-from-group${t ? " " + t : ""}`, ...c, children: /* @__PURE__ */ n(H, { value: s, children: e }) });
+}), M = l(({ children: e, className: t, htmlFor: o }, c) => {
+  const { controlId: r } = g();
+  return /* @__PURE__ */ n("label", { ref: c, htmlFor: o || r, className: `sg-form-label${t ? " " + t : ""}`, children: e });
+}), O = l(({
+  classNameContainer: e,
+  containerRef: t,
+  containerId: o,
+  style: c,
+  classNameLabel: r,
+  labelRef: s,
+  label: m,
+  labelId: u,
+  className: i,
+  type: d,
+  id: x,
+  controlId: f,
+  reverse: p = !1,
+  checkStyle: v,
+  ...a
+}, C) => {
+  let h = f || x, F = d === "switch" ? "checkbox" : d;
+  return /* @__PURE__ */ n("div", { ref: t, id: o, style: c, className: `sg-form-check${p ? "-reverse" : ""}${e ? " " + e : ""}${d === "switch" ? " sg-form-switch" : ""}`, children: p ? /* @__PURE__ */ $(k, { children: [
+    /* @__PURE__ */ n("input", { ref: C, type: F, id: h, className: `sg-form-check-input${i ? " " + i : ""}`, ...a }),
+    /* @__PURE__ */ n("label", { ref: s, id: u, htmlFor: h, className: `sg-form-check-label${r ? " " + r : ""}`, children: m })
+  ] }) : /* @__PURE__ */ $(k, { children: [
+    /* @__PURE__ */ n("label", { ref: s, id: u, htmlFor: h, className: `sg-form-check-label${r ? " " + r : ""}`, children: m }),
+    /* @__PURE__ */ n("input", { ref: C, type: F, id: h, className: `sg-form-check-input${i ? " " + i : ""}`, style: v, ...a })
+  ] }) });
+}), S = l(({ children: e, className: t, ...o }, c) => /* @__PURE__ */ n("small", { ref: c, className: `sg-form-text${t ? " " + t : ""}`, ...o, children: e })), z = Object.assign(P, {
+  Control: y,
+  Select: E,
+  Group: G,
+  Label: M,
+  Check: O,
+  Text: S
+});
+export {
+  w as FormContext,
+  z as default,
+  g as useFormContext
+};

package/dist/InputGroup/index.js

@@ -0,0 +1,7 @@
+import { jsx as u } from "react/jsx-runtime";
+import { forwardRef as e } from "react";
+const n = e(({ children: r, className: t, ...o }, p) => /* @__PURE__ */ u("div", { ref: p, className: `sg-input-group${t ? " " + t : ""}`, ...o, children: r })), s = ({ children: r, className: t, ...o }, p) => /* @__PURE__ */ u("span", { ref: p, className: `sg-input-group-text${t ? " " + t : ""}`, ...o, children: r });
+n.Text = e(s);
+export {
+  n as default
+};