@cognitiv/components-web 1.0.4 → 1.1.0

package/dist/components/error-message/error-message.js

@@ -0,0 +1,22 @@
+"use client";
+import { Text } from 'react-aria-components';
+import { errorMessageVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const ErrorMessageRoot = ({
+  children,
+  className,
+  ...rest
+}) => {
+  return /*#__PURE__*/jsx(Text, {
+    className: errorMessageVariants({
+      className
+    }),
+    "data-slot": "error-message",
+    slot: "errorMessage",
+    ...rest,
+    children: children
+  });
+};
+
+export { ErrorMessageRoot };

package/dist/components/error-message/index.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentProps } from "react";
+import { ErrorMessageRoot } from "./error-message";
+export declare const ErrorMessage: (({ children, className, ...rest }: import("./error-message").ErrorMessageRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, ...rest }: import("./error-message").ErrorMessageRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type ErrorMessage = {
+    Props: ComponentProps<typeof ErrorMessageRoot>;
+    RootProps: ComponentProps<typeof ErrorMessageRoot>;
+};
+export { ErrorMessageRoot };
+export type { ErrorMessageRootProps, ErrorMessageRootProps as ErrorMessageProps, } from "./error-message";
+export { errorMessageVariants } from "./styles";
+export type { ErrorMessageVariants } from "./styles";

package/dist/components/error-message/index.js

@@ -0,0 +1,12 @@
+"use strict";
+import { ErrorMessageRoot } from './error-message.js';
+export { errorMessageVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const ErrorMessage = Object.assign(ErrorMessageRoot, {
+  Root: ErrorMessageRoot
+});
+
+export { ErrorMessage, ErrorMessageRoot };

package/dist/components/error-message/styles.d.ts

@@ -0,0 +1,3 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const errorMessageVariants: import("tailwind-variants").TVReturnType<{} | {} | {}, undefined, "error-message", {} | {}, undefined, import("tailwind-variants").TVReturnType<unknown, undefined, "error-message", unknown, unknown, undefined>>;
+export type ErrorMessageVariants = VariantProps<typeof errorMessageVariants>;

package/dist/components/error-message/styles.js

@@ -0,0 +1,8 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const errorMessageVariants = tv({
+  base: "error-message"
+});
+
+export { errorMessageVariants };

package/dist/components/field-error/field-error.d.ts

@@ -0,0 +1,8 @@
+import type { FieldErrorVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import { FieldError as FieldErrorPrimitive } from "react-aria-components";
+interface FieldErrorRootProps extends ComponentPropsWithRef<typeof FieldErrorPrimitive>, FieldErrorVariants {
+}
+declare const FieldErrorRoot: ({ children, className, ...rest }: FieldErrorRootProps) => import("react/jsx-runtime").JSX.Element;
+export { FieldErrorRoot };
+export type { FieldErrorRootProps };

package/dist/components/field-error/field-error.js

@@ -0,0 +1,21 @@
+"use client";
+import { FieldError } from 'react-aria-components';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { fieldErrorVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const FieldErrorRoot = ({
+  children,
+  className,
+  ...rest
+}) => {
+  return /*#__PURE__*/jsx(FieldError, {
+    "data-visible": true,
+    className: composeTwRenderProps(className, fieldErrorVariants()),
+    "data-slot": "field-error",
+    ...rest,
+    children: renderProps => typeof children === "function" ? children(renderProps) : children
+  });
+};
+
+export { FieldErrorRoot };

package/dist/components/field-error/index.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentProps } from "react";
+import { FieldErrorRoot } from "./field-error";
+export declare const FieldError: (({ children, className, ...rest }: import("./field-error").FieldErrorRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, ...rest }: import("./field-error").FieldErrorRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type FieldError = {
+    Props: ComponentProps<typeof FieldErrorRoot>;
+    RootProps: ComponentProps<typeof FieldErrorRoot>;
+};
+export { FieldErrorRoot };
+export type { FieldErrorRootProps, FieldErrorRootProps as FieldErrorProps } from "./field-error";
+export { fieldErrorVariants } from "./styles";
+export type { FieldErrorVariants } from "./styles";

package/dist/components/field-error/index.js

@@ -0,0 +1,12 @@
+"use strict";
+import { FieldErrorRoot } from './field-error.js';
+export { fieldErrorVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const FieldError = Object.assign(FieldErrorRoot, {
+  Root: FieldErrorRoot
+});
+
+export { FieldError, FieldErrorRoot };

package/dist/components/field-error/styles.d.ts

@@ -0,0 +1,3 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const fieldErrorVariants: import("tailwind-variants").TVReturnType<{} | {} | {}, undefined, "field-error", {} | {}, undefined, import("tailwind-variants").TVReturnType<unknown, undefined, "field-error", unknown, unknown, undefined>>;
+export type FieldErrorVariants = VariantProps<typeof fieldErrorVariants>;

package/dist/components/field-error/styles.js

@@ -0,0 +1,8 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const fieldErrorVariants = tv({
+  base: "field-error"
+});
+
+export { fieldErrorVariants };

package/dist/components/fieldset/fieldset.d.ts

@@ -0,0 +1,16 @@
+import type { FieldsetVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+interface FieldsetRootProps extends ComponentPropsWithRef<"fieldset">, FieldsetVariants {
+}
+declare const FieldsetRoot: ({ className, ...props }: FieldsetRootProps) => import("react/jsx-runtime").JSX.Element;
+interface FieldsetLegendProps extends ComponentPropsWithRef<"legend"> {
+}
+declare const FieldsetLegend: ({ className, ...props }: FieldsetLegendProps) => import("react/jsx-runtime").JSX.Element;
+interface FieldGroupProps extends ComponentPropsWithRef<"div"> {
+}
+declare const FieldGroup: ({ className, ...rest }: FieldGroupProps) => import("react/jsx-runtime").JSX.Element;
+interface FieldsetActionsProps extends ComponentPropsWithRef<"div"> {
+}
+declare const FieldsetActions: ({ children, className, ...rest }: FieldsetActionsProps) => import("react/jsx-runtime").JSX.Element;
+export { FieldsetRoot, FieldsetLegend, FieldGroup, FieldsetActions };
+export type { FieldsetRootProps, FieldsetLegendProps, FieldGroupProps, FieldsetActionsProps };

package/dist/components/fieldset/fieldset.js

@@ -0,0 +1,88 @@
+"use client";
+import React__default, { useContext, createContext } from 'react';
+import { composeSlotClassName } from '../../utils/compose.js';
+import { fieldsetVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const FieldsetContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * Fieldset Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const FieldsetRoot = ({
+  className,
+  ...props
+}) => {
+  const slots = React__default.useMemo(() => fieldsetVariants({}), []);
+  return /*#__PURE__*/jsx(FieldsetContext, {
+    value: {
+      slots
+    },
+    children: /*#__PURE__*/jsx("fieldset", {
+      className: slots?.base({
+        className
+      }),
+      "data-slot": "fieldset",
+      ...props
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Fieldset Legend
+ * -----------------------------------------------------------------------------------------------*/
+
+const FieldsetLegend = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(FieldsetContext);
+  return /*#__PURE__*/jsx("legend", {
+    className: composeSlotClassName(slots?.legend, className),
+    "data-slot": "fieldset-legend",
+    ...props
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Field Group
+ * -----------------------------------------------------------------------------------------------*/
+
+const FieldGroup = ({
+  className,
+  ...rest
+}) => {
+  const {
+    slots
+  } = useContext(FieldsetContext);
+  return /*#__PURE__*/jsx("div", {
+    className: composeSlotClassName(slots?.fieldGroup, className),
+    "data-slot": "fieldset-field-group",
+    ...rest
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Field Actions
+ * -----------------------------------------------------------------------------------------------*/
+
+const FieldsetActions = ({
+  children,
+  className,
+  ...rest
+}) => {
+  const {
+    slots
+  } = useContext(FieldsetContext);
+  return /*#__PURE__*/jsx("div", {
+    className: composeSlotClassName(slots?.actions, className),
+    "data-slot": "fieldset-actions",
+    ...rest,
+    children: children
+  });
+};
+
+export { FieldGroup, FieldsetActions, FieldsetLegend, FieldsetRoot };

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

@@ -0,0 +1,19 @@
+import type { ComponentProps } from "react";
+import { FieldGroup, FieldsetActions, FieldsetLegend, FieldsetRoot } from "./fieldset";
+export declare const Fieldset: (({ className, ...props }: import("./fieldset").FieldsetRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Actions: ({ children, className, ...rest }: import("./fieldset").FieldsetActionsProps) => import("react/jsx-runtime").JSX.Element;
+    Group: ({ className, ...rest }: import("./fieldset").FieldGroupProps) => import("react/jsx-runtime").JSX.Element;
+    Legend: ({ className, ...props }: import("./fieldset").FieldsetLegendProps) => import("react/jsx-runtime").JSX.Element;
+    Root: ({ className, ...props }: import("./fieldset").FieldsetRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Fieldset = {
+    Props: ComponentProps<typeof FieldsetRoot>;
+    RootProps: ComponentProps<typeof FieldsetRoot>;
+    LegendProps: ComponentProps<typeof FieldsetLegend>;
+    GroupProps: ComponentProps<typeof FieldGroup>;
+    ActionsProps: ComponentProps<typeof FieldsetActions>;
+};
+export { FieldsetRoot, FieldsetLegend, FieldGroup, FieldsetActions };
+export type { FieldsetRootProps, FieldsetRootProps as FieldsetProps, FieldsetLegendProps, FieldGroupProps, FieldsetActionsProps, } from "./fieldset";
+export { fieldsetVariants } from "./styles";
+export type { FieldsetVariants } from "./styles";

package/dist/components/fieldset/index.js

@@ -0,0 +1,15 @@
+"use strict";
+import { FieldsetRoot, FieldsetLegend, FieldGroup, FieldsetActions } from './fieldset.js';
+export { fieldsetVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Fieldset = Object.assign(FieldsetRoot, {
+  Actions: FieldsetActions,
+  Group: FieldGroup,
+  Legend: FieldsetLegend,
+  Root: FieldsetRoot
+});
+
+export { FieldGroup, Fieldset, FieldsetActions, FieldsetLegend, FieldsetRoot };

package/dist/components/fieldset/styles.d.ts

@@ -0,0 +1,51 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const fieldsetVariants: import("tailwind-variants").TVReturnType<{
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            base?: import("tailwind-merge").ClassNameValue;
+            legend?: import("tailwind-merge").ClassNameValue;
+            description?: import("tailwind-merge").ClassNameValue;
+            actions?: import("tailwind-merge").ClassNameValue;
+            fieldGroup?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-merge").ClassNameValue | {
+            base?: import("tailwind-merge").ClassNameValue;
+            legend?: import("tailwind-merge").ClassNameValue;
+            description?: import("tailwind-merge").ClassNameValue;
+            actions?: import("tailwind-merge").ClassNameValue;
+            fieldGroup?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    actions: string;
+    base: string;
+    description: string;
+    fieldGroup: string;
+    legend: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            base?: import("tailwind-merge").ClassNameValue;
+            legend?: import("tailwind-merge").ClassNameValue;
+            description?: import("tailwind-merge").ClassNameValue;
+            actions?: import("tailwind-merge").ClassNameValue;
+            fieldGroup?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    actions: string;
+    base: string;
+    description: string;
+    fieldGroup: string;
+    legend: string;
+}, import("tailwind-variants").TVReturnType<unknown, {
+    actions: string;
+    base: string;
+    description: string;
+    fieldGroup: string;
+    legend: string;
+}, undefined, unknown, unknown, undefined>>;
+export type FieldsetVariants = VariantProps<typeof fieldsetVariants>;

package/dist/components/fieldset/styles.js

@@ -0,0 +1,14 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const fieldsetVariants = tv({
+  slots: {
+    actions: "fieldset__actions",
+    base: "fieldset",
+    description: "fieldset__description",
+    fieldGroup: "fieldset__field_group",
+    legend: "fieldset__legend"
+  }
+});
+
+export { fieldsetVariants };

package/dist/components/form/form.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentPropsWithRef } from "react";
+import { Form as FormPrimitive } from "react-aria-components";
+interface FormRootProps extends ComponentPropsWithRef<typeof FormPrimitive> {
+}
+declare const FormRoot: ({ ...props }: FormRootProps) => import("react/jsx-runtime").JSX.Element;
+export { FormRoot };
+export type { FormRootProps };

package/dist/components/form/form.js

@@ -0,0 +1,13 @@
+"use client";
+import { Form } from 'react-aria-components';
+import { jsx } from 'react/jsx-runtime';
+
+const FormRoot = ({
+  ...props
+}) => {
+  return /*#__PURE__*/jsx(Form, {
+    ...props
+  });
+};
+
+export { FormRoot };

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

@@ -0,0 +1,11 @@
+import type { ComponentProps } from "react";
+import { FormRoot } from "./form";
+export declare const Form: (({ ...props }: import("./form").FormRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ ...props }: import("./form").FormRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Form = {
+    Props: ComponentProps<typeof FormRoot>;
+    RootProps: ComponentProps<typeof FormRoot>;
+};
+export { FormRoot };
+export type { FormRootProps, FormRootProps as FormProps } from "./form";

package/dist/components/form/index.js

@@ -0,0 +1,11 @@
+"use strict";
+import { FormRoot } from './form.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Form = Object.assign(FormRoot, {
+  Root: FormRoot
+});
+
+export { Form, FormRoot };

package/dist/components/header/header.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentPropsWithRef } from "react";
+import { Header as HeaderPrimitive } from "react-aria-components";
+interface HeaderRootProps extends ComponentPropsWithRef<typeof HeaderPrimitive> {
+}
+declare const HeaderRoot: ({ children, className, ...rest }: HeaderRootProps) => import("react/jsx-runtime").JSX.Element;
+export { HeaderRoot };
+export type { HeaderRootProps };

package/dist/components/header/header.js

@@ -0,0 +1,21 @@
+"use client";
+import { Header } from 'react-aria-components';
+import { headerVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const HeaderRoot = ({
+  children,
+  className,
+  ...rest
+}) => {
+  return /*#__PURE__*/jsx(Header, {
+    className: headerVariants({
+      className
+    }),
+    "data-slot": "header",
+    ...rest,
+    children: children
+  });
+};
+
+export { HeaderRoot };

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

@@ -0,0 +1,9 @@
+import type { ComponentProps } from "react";
+import { HeaderRoot } from "./header";
+export declare const Header: ({ children, className, ...rest }: import("./header").HeaderRootProps) => import("react/jsx-runtime").JSX.Element;
+export type Header = {
+    Props: ComponentProps<typeof HeaderRoot>;
+};
+export { HeaderRoot };
+export type { HeaderRootProps, HeaderRootProps as HeaderProps } from "./header";
+export { headerVariants } from "./styles";

package/dist/components/header/index.js

@@ -0,0 +1,10 @@
+"use strict";
+import { HeaderRoot } from './header.js';
+export { headerVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Header = HeaderRoot;
+
+export { Header, HeaderRoot };

package/dist/components/header/styles.d.ts

@@ -0,0 +1 @@
+export declare const headerVariants: import("tailwind-variants").TVReturnType<{} | {} | {}, undefined, "header", {} | {}, undefined, import("tailwind-variants").TVReturnType<unknown, undefined, "header", unknown, unknown, undefined>>;

package/dist/components/header/styles.js

@@ -0,0 +1,8 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const headerVariants = tv({
+  base: "header"
+});
+
+export { headerVariants };

package/dist/components/icons.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+interface IconProps extends React.SVGProps<SVGSVGElement> {
+}
+export declare const IconChevronDown: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const IconChevronLeft: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const IconChevronRight: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ExternalLinkIcon: ({ height, width, ...props }: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CircleDashedIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CloseIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const InfoIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const WarningIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DangerIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SuccessIcon: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const IconMinus: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const IconPlus: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const IconSearch: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const IconCalendar: (props: IconProps) => import("react/jsx-runtime").JSX.Element;
+export {};