@konstructio/ui 0.0.2

package/dist/_commonjsHelpers-C6fGbg64.js

@@ -0,0 +1,6 @@
+function e(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+export {
+  e as g
+};

package/dist/chevron-up-Cmu1oXfj.js

@@ -0,0 +1,54 @@
+import l, { forwardRef as c } from "react";
+import { P as a } from "./index-DQMInta3.js";
+function p() {
+  return p = Object.assign || function(e) {
+    for (var o = 1; o < arguments.length; o++) {
+      var t = arguments[o];
+      for (var r in t)
+        Object.prototype.hasOwnProperty.call(t, r) && (e[r] = t[r]);
+    }
+    return e;
+  }, p.apply(this, arguments);
+}
+function u(e, o) {
+  if (e == null) return {};
+  var t = v(e, o), r, n;
+  if (Object.getOwnPropertySymbols) {
+    var i = Object.getOwnPropertySymbols(e);
+    for (n = 0; n < i.length; n++)
+      r = i[n], !(o.indexOf(r) >= 0) && Object.prototype.propertyIsEnumerable.call(e, r) && (t[r] = e[r]);
+  }
+  return t;
+}
+function v(e, o) {
+  if (e == null) return {};
+  var t = {}, r = Object.keys(e), n, i;
+  for (i = 0; i < r.length; i++)
+    n = r[i], !(o.indexOf(n) >= 0) && (t[n] = e[n]);
+  return t;
+}
+var s = c(function(e, o) {
+  var t = e.color, r = t === void 0 ? "currentColor" : t, n = e.size, i = n === void 0 ? 24 : n, f = u(e, ["color", "size"]);
+  return /* @__PURE__ */ l.createElement("svg", p({
+    ref: o,
+    xmlns: "http://www.w3.org/2000/svg",
+    width: i,
+    height: i,
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: r,
+    strokeWidth: "2",
+    strokeLinecap: "round",
+    strokeLinejoin: "round"
+  }, f), /* @__PURE__ */ l.createElement("polyline", {
+    points: "18 15 12 9 6 15"
+  }));
+});
+s.propTypes = {
+  color: a.string,
+  size: a.oneOfType([a.string, a.number])
+};
+s.displayName = "ChevronUp";
+export {
+  s as C
+};

package/dist/components/AlertDialog/AlertDialog.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { AlertDialogProps } from './AlertDialog.types';
+export declare const AlertDialog: FC<AlertDialogProps>;

package/dist/components/AlertDialog/AlertDialog.js

@@ -0,0 +1,54 @@
+import { jsxs as t, jsx as e } from "react/jsx-runtime";
+import { R as h, A as f, P as x, O as g, C as u, T as C, D as b, a as y, b as O } from "../../AlertDialogTrigger-BIbxXexQ.js";
+import "../../contexts/theme.context.js";
+import { useTheme as A } from "../../contexts/theme.hook.js";
+import "react";
+import "../../js.cookie-OLEfuq_g.js";
+import { Button as a } from "../Button/Button.js";
+import { useAlertDialog as D } from "./hooks/useAlertDialog.js";
+const B = ({
+  buttonText: l,
+  theme: n,
+  title: o,
+  description: i,
+  onConfirm: s
+}) => {
+  const { theme: r } = A(), { isOpen: c, handleCancel: d, handleConfirm: m, handleOpen: p } = D({
+    onConfirm: s
+  });
+  return /* @__PURE__ */ t(h, { open: c, children: [
+    /* @__PURE__ */ e(f, { text: l, theme: n, onOpen: p }),
+    /* @__PURE__ */ t(x, { children: [
+      /* @__PURE__ */ e(g, { className: "bg-black opacity-75 inset-0 fixed" }),
+      /* @__PURE__ */ t(u, { className: "bg-white rounded-md fixed top-1/2 left-1/2 -translate-y-2/4 -translate-x-2/4 flex flex-col gap-8 p-6", children: [
+        /* @__PURE__ */ e(C, { className: "font-bold text-center text-2xl", children: o }),
+        /* @__PURE__ */ e(b, { children: i }),
+        /* @__PURE__ */ t("div", { className: "flex flex-row gap-5 justify-end", children: [
+          /* @__PURE__ */ e(y, { asChild: !0, children: /* @__PURE__ */ e(
+            a,
+            {
+              type: "button",
+              theme: n ?? r,
+              variant: "secondary",
+              onClick: d,
+              children: "Cancel"
+            }
+          ) }),
+          /* @__PURE__ */ e(O, { asChild: !0, children: /* @__PURE__ */ e(
+            a,
+            {
+              type: "button",
+              theme: n ?? r,
+              variant: "danger",
+              onClick: m,
+              children: "OK"
+            }
+          ) })
+        ] })
+      ] })
+    ] })
+  ] });
+};
+export {
+  B as AlertDialog
+};

package/dist/components/AlertDialog/AlertDialog.types.d.ts

@@ -0,0 +1,13 @@
+import { PropsWithChildren } from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { buttonAlertDialogVariants } from './AlertDialog.variants';
+export interface AlertDialogProps extends PropsWithChildren, VariantProps<typeof buttonAlertDialogVariants> {
+    className?: string;
+    buttonText?: string;
+    title?: string;
+    description?: string;
+    onConfirm?: () => void;
+}
+export type UseAlertiDialogProps = {
+    onConfirm: AlertDialogProps['onConfirm'];
+};

package/dist/components/AlertDialog/AlertDialog.types.js

@@ -0,0 +1 @@
+

package/dist/components/AlertDialog/AlertDialog.variants.d.ts

@@ -0,0 +1,3 @@
+export declare const buttonAlertDialogVariants: (props?: ({
+    theme?: "kubefirst" | "konstruct" | "colony" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/components/AlertDialog/AlertDialog.variants.js

@@ -0,0 +1,16 @@
+import { c as t } from "../../index-BwYCDOHZ.js";
+const r = t([], {
+  variants: {
+    theme: {
+      colony: "",
+      kubefirst: "",
+      konstruct: ""
+    }
+  },
+  defaultVariants: {
+    theme: "kubefirst"
+  }
+});
+export {
+  r as buttonAlertDialogVariants
+};

package/dist/components/AlertDialog/components/AlertDialogTrigger.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { AlertDialogTriggerProps } from './AlertDialogTrigger.types';
+export declare const AlertDialogTrigger: FC<AlertDialogTriggerProps>;

package/dist/components/AlertDialog/components/AlertDialogTrigger.js

@@ -0,0 +1,10 @@
+import "react/jsx-runtime";
+import { A as a } from "../../../AlertDialogTrigger-BIbxXexQ.js";
+import "../../../contexts/theme.context.js";
+import "../../../contexts/theme.hook.js";
+import "react";
+import "../../../js.cookie-OLEfuq_g.js";
+import "../../Button/Button.js";
+export {
+  a as AlertDialogTrigger
+};

package/dist/components/AlertDialog/components/AlertDialogTrigger.types.d.ts

@@ -0,0 +1,6 @@
+import { VariantProps } from 'class-variance-authority';
+import { buttonAlertDialogVariants } from '../AlertDialog.variants';
+export interface AlertDialogTriggerProps extends VariantProps<typeof buttonAlertDialogVariants> {
+    text?: string;
+    onOpen(): void;
+}

package/dist/components/AlertDialog/components/AlertDialogTrigger.types.js

@@ -0,0 +1 @@
+

package/dist/components/AlertDialog/components/index.d.ts

@@ -0,0 +1 @@
+export * from './AlertDialogTrigger';

package/dist/components/AlertDialog/components/index.js

@@ -0,0 +1,4 @@
+import { A as g } from "../../../AlertDialogTrigger-BIbxXexQ.js";
+export {
+  g as AlertDialogTrigger
+};

package/dist/components/AlertDialog/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useAlertDialog';

package/dist/components/AlertDialog/hooks/index.js

@@ -0,0 +1,4 @@
+import { useAlertDialog as r } from "./useAlertDialog.js";
+export {
+  r as useAlertDialog
+};

package/dist/components/AlertDialog/hooks/useAlertDialog.d.ts

@@ -0,0 +1,7 @@
+import { UseAlertiDialogProps } from '../AlertDialog.types';
+export declare const useAlertDialog: ({ onConfirm }: UseAlertiDialogProps) => {
+    isOpen: boolean;
+    handleCancel: () => void;
+    handleConfirm: () => void;
+    handleOpen: () => void;
+};

package/dist/components/AlertDialog/hooks/useAlertDialog.js

@@ -0,0 +1,10 @@
+import { useState as u, useCallback as t } from "react";
+const d = ({ onConfirm: e }) => {
+  const [a, s] = u(!1), l = t(() => s(!0), []), c = t(() => s(!1), []), p = t(() => {
+    e == null || e(), s(!1);
+  }, [e]);
+  return { isOpen: a, handleCancel: c, handleConfirm: p, handleOpen: l };
+};
+export {
+  d as useAlertDialog
+};

package/dist/components/Autocomplete/Autocomplete.d.ts

@@ -0,0 +1,3 @@
+import { AutocompleteProps } from './Autocomplete.types';
+declare const Autocomplete: import('react').ForwardRefExoticComponent<AutocompleteProps & import('react').RefAttributes<HTMLInputElement>>;
+export { Autocomplete };

package/dist/components/Autocomplete/Autocomplete.js

@@ -0,0 +1,84 @@
+import { jsxs as C, jsx as t } from "react/jsx-runtime";
+import { forwardRef as R, useRef as i, useId as A, useImperativeHandle as T } from "react";
+import "../../contexts/theme.context.js";
+import { useTheme as V } from "../../contexts/theme.hook.js";
+import "../../js.cookie-OLEfuq_g.js";
+import { useAutocomplete as g } from "./hooks/useAutocomplete.js";
+import { List as j } from "./components/List.js";
+import { labelVariants as y, autocompleteVariants as I } from "./Autocomplete.variants.js";
+const O = R(
+  ({
+    autoComplete: p = "off",
+    className: a,
+    label: n,
+    labelClassName: u,
+    name: l,
+    options: d,
+    placeHolderEmptyValues: h = "No values...",
+    placeHolderEmptyValuesClassName: f,
+    placeholder: x,
+    theme: N,
+    variant: r,
+    onChange: w
+  }, b) => {
+    const s = i(null), e = i(null), c = A(), { theme: v } = V(), m = N ?? v;
+    T(b, () => e.current, [e]);
+    const o = g({
+      options: d,
+      inputRef: e,
+      wrapperRef: s,
+      onChange: w
+    });
+    return /* @__PURE__ */ C("div", { ref: s, className: "relative flex flex-col", children: [
+      n ? /* @__PURE__ */ t(
+        "label",
+        {
+          htmlFor: l ?? c,
+          className: y({
+            theme: m,
+            variant: r,
+            className: u
+          }),
+          children: n
+        }
+      ) : null,
+      /* @__PURE__ */ t(
+        "input",
+        {
+          ref: e,
+          id: l ?? c,
+          type: "text",
+          name: l,
+          role: "combobox",
+          autoComplete: p,
+          className: I({
+            theme: m,
+            variant: r,
+            className: a
+          }),
+          onChange: o.handleChange,
+          value: o.value,
+          placeholder: x
+        }
+      ),
+      o.showOptions && /* @__PURE__ */ t("div", { className: "absolute z-10 top-full w-full rounded-md mt-1 border shadow-sm", children: /* @__PURE__ */ t(
+        j,
+        {
+          className: a,
+          inputRef: e,
+          wrapperRef: s,
+          options: o.newOptions,
+          placeholder: h,
+          placeholderClassName: f,
+          variant: r,
+          theme: m,
+          onClick: o.handleSelectValue
+        }
+      ) })
+    ] });
+  }
+);
+O.displayName = "Autocomplete";
+export {
+  O as Autocomplete
+};

package/dist/components/Autocomplete/Autocomplete.types.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { autocompleteVariants } from './Autocomplete.variants';
+export type Option = {
+    value: string;
+};
+export interface AutocompleteProps extends VariantProps<typeof autocompleteVariants> {
+    autoComplete?: 'off';
+    className?: string;
+    label?: string;
+    labelClassName?: string;
+    name?: string;
+    options: Option[];
+    placeHolderEmptyValues?: string | ReactNode;
+    placeHolderEmptyValuesClassName?: string;
+    placeholder?: string;
+    onChange(value: string): void;
+}

package/dist/components/Autocomplete/Autocomplete.types.js

@@ -0,0 +1 @@
+

package/dist/components/Autocomplete/Autocomplete.variants.d.ts

@@ -0,0 +1,8 @@
+export declare const autocompleteVariants: (props?: ({
+    variant?: "default" | null | undefined;
+    theme?: "kubefirst" | "konstruct" | "colony" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const labelVariants: (props?: ({
+    variant?: "default" | null | undefined;
+    theme?: "kubefirst" | "konstruct" | "colony" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/components/Autocomplete/Autocomplete.variants.js

@@ -0,0 +1,61 @@
+import { c as t } from "../../index-BwYCDOHZ.js";
+const r = t(
+  [
+    "flex",
+    "w-full",
+    "rounded-md",
+    "border",
+    "border-zinc-200",
+    "bg-transparent",
+    "text-base",
+    "text-zinc-700",
+    "transition-colors",
+    "placeholder:text-muted-foreground",
+    "focus-visible:outline-none",
+    "focus-visible:ring-1",
+    "focus-visible:ring-ring",
+    "disabled:cursor-not-allowed",
+    "disabled:opacity-50",
+    "shadow-sm",
+    "py-1",
+    "px-2"
+  ],
+  {
+    variants: {
+      variant: {
+        default: ""
+      },
+      theme: {
+        kubefirst: ["focus:ring-kubefirst-purple-light"],
+        konstruct: ["focus:focus:ring-orange-400"],
+        colony: ["focus:focus:ring-red-400"]
+      }
+    },
+    defaultVariants: {
+      theme: "kubefirst",
+      variant: "default"
+    }
+  }
+), a = t(
+  ["pl-1", "mb-2", "text-base", "cursor-pointer"],
+  {
+    variants: {
+      variant: {
+        default: ""
+      },
+      theme: {
+        kubefirst: "",
+        konstruct: "",
+        colony: ""
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      theme: "kubefirst"
+    }
+  }
+);
+export {
+  r as autocompleteVariants,
+  a as labelVariants
+};

package/dist/components/Autocomplete/components/List.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { Props } from './List.types';
+export declare const List: FC<Props>;

package/dist/components/Autocomplete/components/List.js

@@ -0,0 +1,57 @@
+import { jsx as r } from "react/jsx-runtime";
+import { useRef as f } from "react";
+import { useNavigationUlList as p } from "../hooks/useNavigationList.js";
+import { emptyListVariants as b, listVariants as N, listItemVariants as d, buttonVariants as x } from "./List.variants.js";
+const y = ({
+  className: n,
+  inputRef: e,
+  options: l,
+  placeholder: a,
+  placeholderClassName: m,
+  variant: t,
+  theme: s,
+  wrapperRef: c,
+  onClick: u
+}) => {
+  const o = f(null);
+  return p({ ulRef: o, inputRef: e, wrapperRef: c, options: l }), l.length === 0 ? /* @__PURE__ */ r(
+    "span",
+    {
+      className: b({
+        theme: s,
+        variant: t,
+        className: m
+      }),
+      children: a
+    }
+  ) : /* @__PURE__ */ r(
+    "ul",
+    {
+      ref: o,
+      role: "listbox",
+      className: N({ variant: t, theme: s, className: n }),
+      children: l.map(({ value: i }) => /* @__PURE__ */ r(
+        "li",
+        {
+          role: "option",
+          tabIndex: 0,
+          className: d({ theme: s, variant: t }),
+          children: /* @__PURE__ */ r(
+            "button",
+            {
+              type: "button",
+              role: "button",
+              className: x({ theme: s, variant: t }),
+              onClick: () => u(i),
+              children: i
+            }
+          )
+        },
+        i
+      ))
+    }
+  );
+};
+export {
+  y as List
+};

package/dist/components/Autocomplete/components/List.types.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode, RefObject } from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { Option } from '../Autocomplete.types';
+import { autocompleteVariants } from '../Autocomplete.variants';
+export interface Props extends VariantProps<typeof autocompleteVariants> {
+    className?: string;
+    inputRef: RefObject<HTMLInputElement>;
+    wrapperRef: RefObject<HTMLDivElement>;
+    options: Option[];
+    placeholder: string | ReactNode;
+    placeholderClassName?: string;
+    onClick(value: string): void;
+}

package/dist/components/Autocomplete/components/List.types.js

@@ -0,0 +1 @@
+

package/dist/components/Autocomplete/components/List.variants.d.ts

@@ -0,0 +1,16 @@
+export declare const listVariants: (props?: ({
+    variant?: "default" | null | undefined;
+    theme?: "kubefirst" | "konstruct" | "colony" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const emptyListVariants: (props?: ({
+    variant?: "default" | null | undefined;
+    theme?: "kubefirst" | "konstruct" | "colony" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const listItemVariants: (props?: ({
+    variant?: "default" | null | undefined;
+    theme?: "kubefirst" | "konstruct" | "colony" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const buttonVariants: (props?: ({
+    variant?: "default" | null | undefined;
+    theme?: "kubefirst" | "konstruct" | "colony" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/components/Autocomplete/components/List.variants.js

@@ -0,0 +1,81 @@
+import { c as t } from "../../../index-BwYCDOHZ.js";
+const a = t(["max-h-[250px]", "overflow-y-auto"], {
+  variants: {
+    variant: {
+      default: "bg-white"
+    },
+    theme: {
+      kubefirst: "",
+      konstruct: "",
+      colony: ""
+    }
+  },
+  defaultVariants: {
+    variant: "default",
+    theme: "kubefirst"
+  }
+}), r = t(
+  ["p-1", "text-center", "w-full block", "bg-white"],
+  {
+    variants: {
+      variant: {
+        default: ""
+      },
+      theme: {
+        kubefirst: "",
+        konstruct: "",
+        colony: ""
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      theme: "kubefirst"
+    }
+  }
+), o = t(["focus-visible:outline-none"], {
+  variants: {
+    variant: {
+      default: ""
+    },
+    theme: {
+      kubefirst: ["focus:bg-purple-100", "hover:bg-purple-100"],
+      konstruct: ["focus:bg-orange-100", "hover:bg-orange-100"],
+      colony: ["focus:bg-red-100", "hover:bg-red-100"]
+    }
+  },
+  defaultVariants: {
+    variant: "default",
+    theme: "kubefirst"
+  }
+}), n = t(
+  [
+    "cursor-pointer",
+    "focus-visible:outline-none",
+    "px-3",
+    "py-1.5",
+    "w-full",
+    "text-left"
+  ],
+  {
+    variants: {
+      variant: {
+        default: ""
+      },
+      theme: {
+        kubefirst: ["focus:bg-purple-100", "hover:bg-purple-100"],
+        konstruct: ["focus:bg-orange-100", "hover:bg-orange-100"],
+        colony: ["focus:bg-red-100", "hover:bg-red-100"]
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      theme: "kubefirst"
+    }
+  }
+);
+export {
+  n as buttonVariants,
+  r as emptyListVariants,
+  o as listItemVariants,
+  a as listVariants
+};

package/dist/components/Autocomplete/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useAutocomplete';
+export * from './useNavigationList';

package/dist/components/Autocomplete/hooks/index.js

@@ -0,0 +1,6 @@
+import { useAutocomplete as t } from "./useAutocomplete.js";
+import { useNavigationUlList as i } from "./useNavigationList.js";
+export {
+  t as useAutocomplete,
+  i as useNavigationUlList
+};

package/dist/components/Autocomplete/hooks/useAutocomplete.d.ts

@@ -0,0 +1,17 @@
+import { ChangeEvent, RefObject } from 'react';
+import { Option } from '../Autocomplete.types';
+type UseAutocompleteProps = {
+    options: Option[];
+    inputRef: RefObject<HTMLInputElement>;
+    wrapperRef: RefObject<HTMLDivElement>;
+    onChange(value: string): void;
+};
+export declare const useAutocomplete: ({ options, inputRef, wrapperRef, onChange, }: UseAutocompleteProps) => {
+    inputRef: RefObject<HTMLInputElement>;
+    newOptions: Option[];
+    showOptions: boolean;
+    value: string;
+    handleChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    handleSelectValue: (value: string) => void;
+};
+export {};