@akad/design-system 0.1.0-beta.1

package/react/components/molecules/Table/Table.d.ts

@@ -0,0 +1,7 @@
+import { DsTableProps } from './Table.types';
+
+declare const DsTable: {
+    ({ columns, data, className }: DsTableProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default DsTable;

package/react/components/molecules/Table/Table.stories.d.ts

@@ -0,0 +1,12 @@
+import { DsTableRowProps } from './Table.types';
+import { Meta } from '@storybook/react';
+
+declare const componentProps: Meta;
+export default componentProps;
+export declare const Default: {
+    render: import('@storybook/types').AnnotatedStoryFn<import('@storybook/react').ReactRenderer, DsTableRowProps>;
+    args: {
+        columns: import('./Table.types').DsTableColumnsProps[];
+        data: import('./Table.types').DsTableCoverageItem[];
+    };
+};

package/react/components/molecules/Table/Table.test.d.ts

@@ -0,0 +1 @@
+export {};

package/react/components/molecules/Table/Table.types.d.ts

@@ -0,0 +1,21 @@
+export interface DsTableProps {
+    columns: Array<DsTableColumnsProps>;
+    data: Array<DsTableCoverageItem>;
+    className?: string;
+}
+export interface DsTableColumnsProps {
+    name: string;
+    label?: React.ReactNode;
+    size?: string;
+    align?: string;
+    className?: string;
+}
+export interface DsTableCoverageItem {
+    cobertura: React.ReactNode;
+    valor: React.ReactNode;
+    lmi: React.ReactNode;
+}
+export interface DsTableRowProps {
+    columns: Array<DsTableColumnsProps>;
+    item: DsTableCoverageItem;
+}

package/react/components/molecules/Table/TableRow.d.ts

@@ -0,0 +1,7 @@
+import { DsTableRowProps } from './Table.types';
+
+declare const DsTableRow: {
+    ({ item, columns }: DsTableRowProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default DsTableRow;

package/react/components/molecules/Table/dataTable.mock.d.ts

@@ -0,0 +1,5 @@
+import { DsTableColumnsProps, DsTableCoverageItem } from './Table.types';
+
+declare const contentDataCoverages: DsTableCoverageItem[];
+declare const columnsData: DsTableColumnsProps[];
+export { contentDataCoverages, columnsData };

package/react/components/molecules/Table/index.d.ts

@@ -0,0 +1,5 @@
+import { DsTableProps } from './Table.types';
+import { default as DsTable } from './Table';
+
+export { DsTable };
+export type { DsTableProps };

package/react/components/molecules/Tabs/Tab.d.ts

@@ -0,0 +1,5 @@
+import { DsTabProps } from '../../../types/types';
+import { default as React } from 'react';
+
+declare const DsTab: React.FC<DsTabProps>;
+export default DsTab;

package/react/components/molecules/Tabs/Tabs.config.d.ts

@@ -0,0 +1,45 @@
+export declare const Color: {
+    readonly None: "";
+    readonly Primary: "primary";
+    readonly Secondary: "secondary";
+    readonly Neutral: "neutral";
+    readonly Success: "success";
+    readonly Warning: "warning";
+    readonly Danger: "danger";
+    readonly Info: "info";
+};
+export type Color = (typeof Color)[keyof typeof Color];
+export interface TabsProps {
+    type: ArrayConstructor;
+    required: boolean;
+}
+export interface SelectedTabProps {
+    type: NumberConstructor;
+    default: number;
+}
+export interface ColorProps {
+    type: StringConstructor;
+    default: Color;
+    options: Color[];
+}
+export interface ClassNameProps {
+    type: StringConstructor;
+    default: string;
+}
+export interface OnChangeProps {
+    type: FunctionConstructor;
+    default: () => void;
+}
+export interface DsTabsConfig {
+    name: string;
+    class: string;
+    props: {
+        tabs: TabsProps;
+        selectedTab: SelectedTabProps;
+        color: ColorProps;
+        className: ClassNameProps;
+        onChange: OnChangeProps;
+    };
+}
+declare const DsTabsConfig: DsTabsConfig;
+export default DsTabsConfig;

package/react/components/molecules/Tabs/Tabs.d.ts

@@ -0,0 +1,12 @@
+import { DsTabProps } from '../../../types/types';
+import { default as React } from 'react';
+
+export interface DsTabsProps {
+    tabs: DsTabProps[];
+    selectedTab?: number;
+    color?: string;
+    className?: string;
+    onChange?: (index: number) => void;
+}
+declare const DsTabs: React.FC<DsTabsProps>;
+export default DsTabs;

package/react/components/molecules/Tabs/Tabs.stories.d.ts

@@ -0,0 +1,24 @@
+import { DsTabsProps } from './Tabs';
+import { Meta } from '@storybook/react';
+
+declare const componentProps: Meta;
+export default componentProps;
+export declare const Default: {
+    render: import('@storybook/types').AnnotatedStoryFn<import('@storybook/react').ReactRenderer, DsTabsProps>;
+    args: {
+        color: import('./Tabs.config').Color;
+        selectedTab: number;
+        tabs: ({
+            name: string;
+            title: import("react/jsx-runtime").JSX.Element;
+            content: import("react/jsx-runtime").JSX.Element;
+            disabled?: undefined;
+        } | {
+            name: string;
+            title: string;
+            content: string;
+            disabled: boolean;
+        })[];
+        onChange: import('@storybook/addon-actions').HandlerFunction;
+    };
+};

package/react/components/molecules/Tabs/index.d.ts

@@ -0,0 +1,6 @@
+import { DsTabProps } from '../../../types/types';
+import { default as DsTabs, DsTabsProps } from './Tabs';
+import { default as DsTab } from './Tab';
+
+export { DsTab, DsTabs };
+export type { DsTabProps, DsTabsProps };

package/react/components/molecules/ThemeProvider/ThemeProvider.config.d.ts

@@ -0,0 +1,30 @@
+export declare const Theme: {
+    readonly Light: "light";
+    readonly Dark: "dark";
+};
+export type Theme = (typeof Theme)[keyof typeof Theme];
+export declare const Library: {
+    readonly Core: "core";
+    readonly Marketing: "mkt";
+};
+export type Library = (typeof Library)[keyof typeof Library];
+export interface ThemeProps {
+    type: StringConstructor;
+    default: Theme;
+    options: Theme[];
+}
+export interface LibraryProps {
+    type: StringConstructor;
+    default: Library;
+    options: Library[];
+}
+export interface ThemeProviderConfig {
+    name: string;
+    class: string;
+    props: {
+        theme: ThemeProps;
+        library: LibraryProps;
+    };
+}
+declare const ThemeProviderConfig: ThemeProviderConfig;
+export default ThemeProviderConfig;

package/react/components/molecules/ThemeProvider/ThemeProvider.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { default as PropTypes } from 'prop-types';
+
+export interface ThemeProviderProps {
+    library: string;
+    children: ReactNode;
+    theme: string;
+}
+declare function ThemeProvider({ library, children, theme }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+declare namespace ThemeProvider {
+    var propTypes: {
+        library: PropTypes.Requireable<string>;
+        children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+        theme: PropTypes.Requireable<string>;
+    };
+}
+export default ThemeProvider;

package/react/components/molecules/ThemeProvider/index.d.ts

@@ -0,0 +1,4 @@
+import { default as ThemeProvider, ThemeProviderProps } from './ThemeProvider';
+
+export { ThemeProvider };
+export type { ThemeProviderProps };

package/react/components/organisms/NotificationList/NotificationList.config.d.ts

@@ -0,0 +1,33 @@
+export declare const Position: {
+    readonly TopLeft: "top-left";
+    readonly TopCenter: "top-center";
+    readonly TopRight: "top-right";
+    readonly BottomLeft: "bottom-left";
+    readonly BottomCenter: "bottom-center";
+    readonly BottomRight: "bottom-right";
+};
+export type Position = (typeof Position)[keyof typeof Position];
+export interface PositionProps {
+    type: StringConstructor;
+    default: Position;
+    options: Position[];
+}
+export interface FluidProps {
+    type: BooleanConstructor;
+    default: boolean;
+}
+export interface ClassNameProps {
+    type: StringConstructor;
+    default: string;
+}
+export interface DsNotificationListConfig {
+    name: string;
+    class: string;
+    props: {
+        position: PositionProps;
+        fluid: FluidProps;
+        className: ClassNameProps;
+    };
+}
+declare const DsNotificationListConfig: DsNotificationListConfig;
+export default DsNotificationListConfig;

package/react/components/organisms/NotificationList/NotificationList.d.ts

@@ -0,0 +1,21 @@
+import { DsNotificationProps } from '../../molecules/Notification';
+import { default as PropTypes } from 'prop-types';
+
+export interface DsNotificationListProps {
+    className?: string;
+    position: string;
+    fluid: boolean;
+    notifications: DsNotificationProps[];
+    removeNotification: (notificationid: string) => void;
+}
+declare const DsNotificationList: {
+    ({ className, position, fluid, notifications, removeNotification, }: DsNotificationListProps): import("react/jsx-runtime").JSX.Element;
+    propTypes: {
+        position: PropTypes.Requireable<import('./NotificationList.config').Position>;
+        fluid: PropTypes.Requireable<boolean>;
+        notifications: PropTypes.Requireable<any[]>;
+        removeNotification: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    displayName: string;
+};
+export default DsNotificationList;

package/react/components/organisms/NotificationList/NotificationList.stories.d.ts

@@ -0,0 +1,27 @@
+import { DsNotificationListProps } from '.';
+import { Meta } from '@storybook/react';
+
+declare const ComponentProps: Meta;
+export default ComponentProps;
+export declare const Default: {
+    render: import('@storybook/types').AnnotatedStoryFn<import('@storybook/react').ReactRenderer, DsNotificationListProps>;
+    args: {
+        notifications: ({
+            id: `${string}-${string}-${string}-${string}-${string}`;
+            type: string;
+            message: import("react/jsx-runtime").JSX.Element;
+            autoClose: boolean;
+            autoCloseTimer: number;
+            progressBar: boolean;
+        } | {
+            id: `${string}-${string}-${string}-${string}-${string}`;
+            type: string;
+            message: import("react/jsx-runtime").JSX.Element;
+            autoClose?: undefined;
+            autoCloseTimer?: undefined;
+            progressBar?: undefined;
+        })[];
+        fluid: boolean;
+        position: import('./NotificationList.config').Position;
+    };
+};

package/react/components/organisms/NotificationList/index.d.ts

@@ -0,0 +1,4 @@
+import { default as DsNotificationList, DsNotificationListProps } from './NotificationList';
+
+export { DsNotificationList };
+export type { DsNotificationListProps };

package/react/components/templates/TwoColumns/TwoColumns.config.d.ts

@@ -0,0 +1,7 @@
+export interface TwoColumnsConfig {
+    name: string;
+    class: string;
+    props: Record<string, never>;
+}
+declare const TwoColumnsConfig: TwoColumnsConfig;
+export default TwoColumnsConfig;

package/react/components/templates/TwoColumns/TwoColumns.d.ts

@@ -0,0 +1,19 @@
+import { default as PropTypes } from 'prop-types';
+
+export interface DsTwoColumnsProps {
+    breadcrumb?: React.ReactElement;
+    header: React.ReactElement;
+    main: React.ReactElement;
+    sidebar: React.ReactElement;
+}
+declare const DsTwoColumns: {
+    ({ header, main, sidebar, breadcrumb, }: DsTwoColumnsProps): import("react/jsx-runtime").JSX.Element;
+    propTypes: {
+        breadcrumb: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        header: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        main: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        sidebar: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    displayName: string;
+};
+export default DsTwoColumns;

package/react/components/templates/TwoColumns/index.d.ts

@@ -0,0 +1,5 @@
+import { default as DsTwoColumns, DsTwoColumnsProps } from './TwoColumns';
+
+export { DsTwoColumns };
+export type { DsTwoColumnsProps };
+export default DsTwoColumns;

package/react/decorators/storybook.d.ts

@@ -0,0 +1,3 @@
+import { StoryFn } from '@storybook/react';
+
+export declare const centralizeBoxDecorator: ((Story: StoryFn) => import("react/jsx-runtime").JSX.Element)[];

package/react/helpers/messageParser.d.ts

@@ -0,0 +1,11 @@
+import { ValidateFunction } from 'ajv';
+
+/**
+ * @description Verify if error from validator has a custom errorMessage. When it's a
+ * default error message, cals translatError
+ * @param validator Validator Function from ajv
+ * @param schemaId - OPTIONAL - schema $id used for validation. It's null/undefined when validating full JSON schema
+ * @returns
+ */
+export declare const parseError: (validator: ValidateFunction, schemaId?: string) => {} | undefined;
+export default parseError;

package/react/helpers/utils.d.ts

@@ -0,0 +1,57 @@
+import { FormSchema } from '../types/hooks/types';
+
+/**
+ * @description Create object key structure for a string path
+ * I.e path: user.name, value: 'Gabriel' -> { user: { name: 'Gabriel' } }
+ * @param target Object to be assigned
+ * @param path Value path inside object. I.e user.address.cep
+ * @param value Value to be inserted inside object
+ */
+export declare const customAssign: <T extends Record<string, unknown>>(target: T, path: Array<string>, value: string | number | boolean | undefined | Array<object> | object) => void;
+/**
+ * @description Verify if a string is an object with a valid JSON structure. It was created to
+ * parse values from option HTML tag.
+ * @param value String to be verified if it's a valid object or not
+ * @returns { isObject, parsedObj}
+ */
+export declare const isValidObject: (value: string) => {
+    isObj: boolean;
+    parsedObj: JSON | undefined;
+};
+/**
+ * @description Parse option value to correct format. Option HTML tag only return string,
+ * so it's necessary to verify if the value is boolean, number or object.
+ * @param value Value from option input
+ * @returns {string|boolean|object} value
+ */
+export declare const parseOptionValue: (value: string) => string | boolean | object | number;
+/**
+ * @description Retrieves the schema properties with the specified schemaId from the formSchema.
+ * @param schemaId - The ID of the schema properties to retrieve.
+ * @param formSchema - The form schema containing the definitions.
+ * @returns The schema property with the specified schemaId, or null if not found.
+ */
+export declare const getSchemaProperties: (schemaId: string, formSchema: JSONSchemaType<{
+    $id: string;
+    type: "object";
+    schemas?: {
+        mainSchema: {
+            $id: string;
+            type: "object";
+            required: string[];
+            properties: {
+                effectiveDate: {
+                    $ref: string;
+                };
+            };
+        };
+        definitions?: Record<string, FormSchema> | undefined;
+    } | undefined;
+    definitions?: Record<string, FormSchema> | undefined;
+}>) => FormSchema | null;
+/**
+ * @description Returns email or password type if it's defined in the schema. If not, returns text as default.
+ * @param definition - Definition from JSON schema
+ * @returns return input type, i.e password or email. If it's not defined, returns text as default.
+ */
+export declare const getInputTypeByFormat: (definition: object) => string;

package/react/helpers/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/react/helpers/validator.d.ts

@@ -0,0 +1,3 @@
+import { default as Ajv } from 'ajv';
+
+export declare const createAjvInstance: () => Ajv;

package/react/hooks/index.d.ts

@@ -0,0 +1,6 @@
+import { useStepper } from './useStepper';
+import { useNotification } from './useNotification';
+import { useMediaQuery } from './useMediaQuery';
+import { useForm } from './useForm';
+
+export { useForm, useStepper, useNotification, useMediaQuery };

package/react/hooks/useForm.d.ts

@@ -0,0 +1,36 @@
+import { FormSchema, EventData, FormValidated, FormDataParsed } from '../types/hooks/types';
+import { default as React } from 'react';
+import { default as Ajv, JSONSchemaType } from 'ajv';
+
+export declare const useForm: ({ formSchema, initialValue, }: {
+    formSchema: JSONSchemaType<FormSchema>;
+    initialValue: FormDataParsed;
+}) => {
+    getFormSchema: JSONSchemaType<FormSchema>;
+    getFormEvent: EventData;
+    setFormData: React.Dispatch<React.SetStateAction<EventData>>;
+    getFormData: FormDataParsed;
+    getInputValidateStatus: (inputName: keyof FormDataParsed) => string;
+    getInputValidateMessage: (inputName: keyof FormDataParsed) => string | undefined;
+    getInputSchema: (inputName: string) => FormSchema | null;
+    isFormDirty: boolean;
+    handleFocused: (inputName: string) => void;
+    handleFormInput: ($event: React.ChangeEvent<HTMLInputElement>) => void;
+    handleFormFlagFields: (flagkey: string, value: string) => void;
+    handleCustomValue: (key: keyof FormDataParsed, value: object | Array<object> | string) => void;
+    clearFormDataKey: (schemaId: string) => void;
+    getFormValidated: FormValidated;
+    getFormFlagFields: {};
+    validateForm: ({ touched }: {
+        touched?: boolean;
+    }) => FormValidated;
+    validateFormSchema: (schemaId: string, schemaData: FormDataParsed, options?: {
+        touched?: boolean;
+    }) => FormValidated;
+    parseFormToObject: () => {
+        toJson: () => string;
+    };
+    clearFormData: () => void;
+    register: (inputName: string) => {};
+    ajv: Ajv | undefined;
+};

package/react/hooks/useMediaQuery.d.ts

@@ -0,0 +1 @@
+export declare function useMediaQuery(query: string): boolean;

package/react/hooks/useNotification.d.ts

@@ -0,0 +1,8 @@
+import { DsNotificationProps } from '../components/molecules/Notification';
+
+export declare const useNotification: () => {
+    notifications: [] | DsNotificationProps[];
+    setNotifications: import('react').Dispatch<import('react').SetStateAction<[] | DsNotificationProps[]>>;
+    addNotification: (notification: DsNotificationProps) => void;
+    removeNotification: (notificationId: string) => void;
+};

package/react/hooks/useStepper.d.ts

@@ -0,0 +1,31 @@
+import { DsStepProps } from '../types/types';
+import { default as React } from 'react';
+
+export declare const useStepper: (initialState?: DsStepProps[], selectedState?: number) => {
+    getSteps: DsStepProps[];
+    getStep: (stepParam: number | string | DsStepProps) => {
+        index: number;
+        disabled?: boolean | undefined;
+        icon: string;
+        label: string;
+        name: string;
+    };
+    getStepSelected: {
+        index: number;
+        disabled?: boolean | undefined;
+        icon: string;
+        label: string;
+        name: string;
+    };
+    getStepIndexByName: (stepNameParam: string) => number;
+    setSteps: (arraySteps: React.SetStateAction<DsStepProps[]>) => void;
+    setStepSelected: (stepParam: number | string | DsStepProps) => void;
+    goToNextStep: () => void;
+    goToPrevStep: () => void;
+    canGoToNextStep: boolean;
+    canGoToPrevStep: boolean;
+    isStep: (stepParam: number | string | DsStepProps) => boolean;
+    isLastStep: boolean;
+    disableSteps: (stepNameParam: string | Array<string>) => DsStepProps[];
+    disableStepsAfter: (stepNameParam: string) => DsStepProps[];
+}[];

package/react/main.d.ts

@@ -0,0 +1,3 @@
+export * from './components/index';
+export * from './hooks/index';
+export * from './helpers/utils';

package/react/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@akad/react",
+  "version": "1.0.0",
+  "main": "./react-lib.umd.cjs",
+  "module": "./react-lib.js",
+  "exports": {
+    ".": {
+      "import": "./react-lib.js",
+      "require": "./react-lib.umd.cjs"
+    }
+  },
+  "types": "./main.d.ts"
+}