@mw-kit/mw-ui 1.9.2 → 1.10.0

package/dist/assets/icons/fontawesome/regular/index.d.ts

@@ -0,0 +1,11 @@
+import type * as FontAwesome from '@fortawesome/free-regular-svg-icons';
+import type { CamelToKebab } from '../../../../interfaces';
+type FontAwesomeRegularIcons = typeof FontAwesome;
+type FontAwesomeSourceIcon = keyof {
+    [K in keyof FontAwesomeRegularIcons as FontAwesomeRegularIcons[K] extends FontAwesome.IconDefinition ? K : never]: FontAwesomeRegularIcons[K];
+};
+type FontAwesomeRegularIcon = keyof {
+    [K in FontAwesomeSourceIcon as CamelToKebab<K extends `fa${infer Rest}` ? `${Rest}-outline` : `${K}-outline`>]: K;
+};
+declare const icons: { [K in FontAwesomeRegularIcon]: FontAwesome.IconDefinition; };
+export default icons;

package/dist/assets/icons/fontawesome/solid/index.d.ts

@@ -0,0 +1,11 @@
+import type * as FontAwesome from '@fortawesome/free-solid-svg-icons';
+import type { CamelToKebab } from '../../../../interfaces';
+type FontAwesomeSolidIcons = typeof FontAwesome;
+type FontAwesomeSourceIcon = keyof {
+    [K in keyof FontAwesomeSolidIcons as FontAwesomeSolidIcons[K] extends FontAwesome.IconDefinition ? K : never]: FontAwesomeSolidIcons[K];
+};
+type FontAwesomeSolidIcon = keyof {
+    [K in FontAwesomeSourceIcon as CamelToKebab<K extends `fa${infer Rest}` ? Rest : K>]: K;
+};
+declare const icons: { [K in FontAwesomeSolidIcon]: FontAwesome.IconDefinition; };
+export default icons;

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

@@ -1,3 +1,3 @@
-import type { IconProps } from './interfaces';
-declare const Icon: (props: IconProps) => JSX.Element;
+import React from 'react';
+declare const Icon: React.ForwardRefExoticComponent<(Omit<import("./interfaces").FontAwesomeIcon, "ref"> | Omit<import("./interfaces").FeatherIcon, "ref"> | Omit<import("./interfaces").SVGIcon, "ref">) & React.RefAttributes<SVGSVGElement>>;
 export default Icon;

package/dist/components/Icon/interfaces.d.ts

@@ -1,34 +1,23 @@
 import type React from 'react';
-import type { SemanticICONS } from 'semantic-ui-react';
-import type { colors } from '../../theme/constants';
+import type fontawesome from '../../assets/icons/fontawesome';
+import type { ThemeInterface } from '../../interfaces';
 import type feather from '.././../assets/icons/feather';
-export interface CommonProps {
-    color?: typeof colors | string;
-    width?: string | number;
-    height?: string | number;
-}
-export interface SemanticIcon extends CommonProps {
-    type: 'semantic';
-    icon: SemanticICONS;
-    onClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
-}
-export interface FeatherIcon extends CommonProps {
+export type CommonProps = Omit<React.SVGProps<SVGSVGElement>, 'children' | 'mask' | 'transform' | 'color'> & {
+    color?: string | Parameters<ThemeInterface['getColor']>;
+    pointer?: boolean;
+};
+export type FontAwesomeIcon = CommonProps & {
+    /** @see https://fontawesome.com/search?ic=free-collection */
+    type: 'fontawesome';
+    icon: keyof typeof fontawesome;
+};
+export type FeatherIcon = CommonProps & {
+    /** @see https://feathericons.com */
     type: 'feather';
     icon: keyof typeof feather;
-    onClick?: (event: React.MouseEvent<SVGElement, MouseEvent>) => void;
-    strokeWidth?: string;
-}
-export interface SVGIcon extends CommonProps {
+};
+export type SVGIcon = CommonProps & {
     type: 'svg';
-    icon: React.FunctionComponent<React.SVGAttributes<SVGElement>>;
-    onClick?: (event: React.MouseEvent<SVGElement, MouseEvent>) => void;
-    strokeWidth?: string;
-}
-export interface JSXIcon {
-    color?: typeof colors | string;
-    type: 'jsx';
-    icon: JSX.Element;
-    width: string | number;
-}
-export type ExtendsCommon = SemanticIcon | FeatherIcon | SVGIcon;
-export type IconProps = SemanticIcon | FeatherIcon | SVGIcon | JSXIcon;
+    icon: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+};
+export type IconProps = FontAwesomeIcon | FeatherIcon | SVGIcon;

package/dist/components/Icon/styled.d.ts

@@ -1,14 +1,8 @@
-import { Icon } from 'semantic-ui-react';
-interface SemanticIconProps {
-    $fontcolor: string;
-    $width?: string | number;
-    $height?: string | number;
-}
-export declare const SemanticIcon: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<Omit<import("semantic-ui-react").IconProps, "ref"> & import("react").RefAttributes<Icon>, SemanticIconProps>> & string & Omit<typeof Icon, keyof import("react").Component<any, {}, any>>;
-interface SVGContainerProps extends Omit<React.HtmlHTMLAttributes<HTMLDivElement>, 'color'> {
-    $color: string;
-    $strokeWidth?: string;
+type SVGContainerProps = {
     $pointer: boolean;
-}
+    $hasWidth: boolean;
+    $hasHeight: boolean;
+    $hasStrokeWidth: boolean;
+};
 export declare const SVGContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, SVGContainerProps>> & string;
 export {};

package/dist/components/Input/components/Input/interfaces.d.ts

@@ -9,7 +9,11 @@ export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement>
     loading?: boolean;
     mask?: Mask;
     icon?: {
-        icon: IconProps;
+        icon: IconProps | {
+            type: 'jsx';
+            icon: JSX.Element;
+            width?: string | number;
+        };
         position?: 'left' | 'right';
     };
     clearable?: boolean | (() => void);

package/dist/components/Menu/interfaces.d.ts

@@ -1,10 +1,14 @@
 import type React from 'react';
-import type { PopupProps } from 'semantic-ui-react';
 import type { Borders, GenericObject, ReactNode, SpacingOrZero, Spacings } from '../../interfaces';
 import type { AbsoluteContainerProps } from '../AbsoluteContainer/interfaces';
+import type { PopupProps } from '../Popup/types';
 import type { ScrollContainerProps } from '../ScrollContainer/interfaces';
 /** funcao que fara a validacao da regra, deve retornar true caso passe na validacao, e false ou o conteudo do popup caso contrario */
-type Rule<T extends GenericObject = GenericObject> = (index: number, data: T) => boolean | Omit<PopupProps, 'trigger'>;
+type Rule<T extends GenericObject = GenericObject> = (index: number, data: T) => boolean | {
+    on?: PopupProps['on'];
+    position?: PopupProps['position'];
+    content: PopupProps['content'];
+};
 export type MenuOptionLabelProps<T extends GenericObject = GenericObject> = {
     delimiter?: boolean;
     keepOpen?: boolean;

package/dist/components/Popup/hooks/fallbackPlacements/index.d.ts

@@ -1,3 +1,3 @@
-import type { PopupPlacement, PopupProps } from '../../types';
-declare const useFallbackPlacements: (props: PopupProps) => PopupPlacement[];
+import type { PopupPosition, PopupProps } from '../../types';
+declare const useFallbackPlacements: (props: PopupProps) => PopupPosition[];
 export default useFallbackPlacements;

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

@@ -1,9 +1,9 @@
 import type { PopupProps } from './types';
 export declare const TooltipArrow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
-    $placement: PopupProps["placement"];
+    $placement: PopupProps["position"];
     $arrow?: Exclude<PopupProps["arrow"], "none">;
 }>> & string;
 export declare const TooltipSurface: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
-    $placement: PopupProps["placement"];
+    $placement: PopupProps["position"];
     $background?: PopupProps["background"];
 }>> & string;

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

@@ -1,6 +1,6 @@
 export type PopupProps<T extends React.ElementType = 'div'> = {
     content: React.FunctionComponent;
-    placement: PopupPlacement;
+    position: PopupPosition;
     on?: 'hover' | 'click';
     triggerType?: T;
     triggerProps?: React.ComponentPropsWithRef<T>;
@@ -12,7 +12,7 @@ export type PopupProps<T extends React.ElementType = 'div'> = {
     closeOnClip?: boolean;
     open?: boolean;
     setOpen?: (open: boolean) => void;
-    fallbackPlacements?: PopupPlacement[];
+    fallbackPlacements?: PopupPosition[];
     zIndex?: number;
 };
-export type PopupPlacement = 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end';
+export type PopupPosition = 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end';

package/dist/functions/inflections.d.ts

@@ -0,0 +1,47 @@
+export type KebabToCamel<T extends string> = {
+    [S in T]: S extends `${infer H}-${infer T}` ? `${H}${Capitalize<KebabToCamel<T>>}` : S;
+}[T];
+export type KebabToPascal<T extends string> = {
+    [S in T]: Capitalize<KebabToCamel<S>>;
+}[T];
+export type KebabToSnake<T extends string> = {
+    [S in T]: S extends `${infer H}-${infer T}` ? `${H}_${KebabToSnake<T>}` : S;
+}[T];
+export type CamelToKebab<T extends string> = {
+    [S in T]: S extends `${infer F}${infer R}` ? R extends Uncapitalize<R> ? `${Lowercase<F>}${CamelToKebab<R>}` : `${Lowercase<F>}-${CamelToKebab<Uncapitalize<R>>}` : S;
+}[T];
+export type CamelToPascal<T extends string> = KebabToPascal<CamelToKebab<T>>;
+export type CamelToSnake<T extends string> = KebabToSnake<CamelToKebab<T>>;
+export type PascalToKebab<T extends string> = {
+    [S in T]: CamelToKebab<Uncapitalize<S>>;
+}[T];
+export type PascalToCamel<T extends string> = KebabToCamel<PascalToKebab<T>>;
+export type PascalToSnake<T extends string> = KebabToSnake<PascalToKebab<T>>;
+export type SnakeToKebab<T extends string> = {
+    [S in T]: S extends `${infer H}_${infer T}` ? `${Lowercase<H>}-${SnakeToKebab<T>}` : Lowercase<S>;
+}[T];
+export type SnakeToPascal<T extends string> = KebabToPascal<SnakeToKebab<T>>;
+export type SnakeToCamel<T extends string> = KebabToCamel<SnakeToKebab<T>>;
+declare const Inflector: {
+    readonly Kebab: {
+        readonly toCamel: <T extends string>(str: T) => KebabToCamel<T>;
+        readonly toPascal: <T extends string>(str: T) => KebabToPascal<T>;
+        readonly toSnake: <T extends string>(str: T) => KebabToSnake<T>;
+    };
+    readonly Camel: {
+        readonly toKebab: <T extends string>(str: T) => CamelToKebab<T>;
+        readonly toPascal: <T extends string>(str: T) => CamelToPascal<T>;
+        readonly toSnake: <T extends string>(str: T) => CamelToSnake<T>;
+    };
+    readonly Pascal: {
+        readonly toKebab: <T extends string>(str: T) => PascalToKebab<T>;
+        readonly toCamel: <T extends string>(str: T) => PascalToCamel<T>;
+        readonly toSnake: <T extends string>(str: T) => PascalToSnake<T>;
+    };
+    readonly Snake: {
+        readonly toKebab: <T extends string>(str: T) => SnakeToKebab<T>;
+        readonly toPascal: <T extends string>(str: T) => SnakeToPascal<T>;
+        readonly toCamel: <T extends string>(str: T) => SnakeToCamel<T>;
+    };
+};
+export default Inflector;