@rebnd/ui 0.0.2 → 0.0.4

package/dist/src/components/RCheckboxGroup/utils/checkbox-group.style.d.ts

@@ -0,0 +1,35 @@
+declare const group: import('../../../../styled-system/types').RecipeRuntimeFn<{
+    orientation: {
+        horizontal: {
+            flexDirection: "row";
+        };
+        vertical: {
+            flexDirection: "column";
+        };
+    };
+    variant: {
+        list: {};
+        card: {
+            '& > label': {
+                border: "1px solid";
+                borderColor: "input.border";
+                borderRadius: "sm";
+            };
+            '& > label:has(input:checked)': {
+                borderColor: "primary.800";
+            };
+        };
+        grid: {
+            gap: "0";
+            overflow: "hidden";
+            border: "1px solid";
+            borderColor: "input.border";
+            borderRadius: "sm";
+            '& > label:has(input:checked)': {
+                backgroundColor: "primary.200";
+            };
+        };
+    };
+}>;
+declare const wrapper: import('../../../../styled-system/types').SystemStyleObject;
+export { group, wrapper };

package/dist/src/components/RFormGroup/RFormGroup.d.ts

@@ -1,9 +1,15 @@
+import { SlotsType, VNode } from 'vue';
+interface Slots {
+    label?: () => VNode[];
+    default: () => VNode[];
+    helperText?: () => VNode[];
+}
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     name: {
         type: StringConstructor;
         default: string;
     };
-}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     name: {
@@ -12,5 +18,5 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     };
 }>> & Readonly<{}>, {
     name: string;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, SlotsType<Slots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/src/components/RInput/RInput.d.ts

@@ -1,3 +1,8 @@
+import { SlotsType, VNode } from 'vue';
+interface Slots {
+    leading?: () => VNode[];
+    trailing?: () => VNode[];
+}
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     hasError: {
         type: BooleanConstructor;
@@ -7,7 +12,12 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         type: StringConstructor;
         default: string;
     };
-}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    radius: {
+        type: import('vue').PropType<import('../../types').Rounded>;
+        default: import('../../types').Rounded;
+        validator: (radii: import('../../types').Rounded) => boolean;
+    };
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     hasError: {
@@ -18,10 +28,16 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         type: StringConstructor;
         default: string;
     };
+    radius: {
+        type: import('vue').PropType<import('../../types').Rounded>;
+        default: import('../../types').Rounded;
+        validator: (radii: import('../../types').Rounded) => boolean;
+    };
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
 }>, {
-    hasError: boolean;
+    radius: import('../../types').Rounded;
     modelValue: string;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    hasError: boolean;
+}, SlotsType<Slots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/src/components/RInput/utils/input.props.d.ts

@@ -1,3 +1,5 @@
+import { PropType } from 'vue';
+import { Rounded } from '../../../types';
 declare const _default: {
     hasError: {
         type: BooleanConstructor;
@@ -7,5 +9,10 @@ declare const _default: {
         type: StringConstructor;
         default: string;
     };
+    radius: {
+        type: PropType<Rounded>;
+        default: Rounded;
+        validator: (radii: Rounded) => boolean;
+    };
 };
 export default _default;

package/dist/src/components/RInput/utils/input.style.d.ts

@@ -1,2 +1,24 @@
-declare const styles: string;
-export { styles };
+declare const wrapper: string;
+declare const input: import('../../../../styled-system/types').RecipeRuntimeFn<{
+    radius: {
+        sharp: {
+            borderRadius: "sharp";
+        };
+        xs: {
+            borderRadius: "xs";
+        };
+        sm: {
+            borderRadius: "sm";
+        };
+        md: {
+            borderRadius: "md";
+        };
+        lg: {
+            borderRadius: "lg";
+        };
+        pill: {
+            borderRadius: "pill";
+        };
+    };
+}>;
+export { input, wrapper };

package/dist/src/components/RInputPassword/RInputPassword.d.ts

@@ -0,0 +1,22 @@
+export declare enum StrengthLevel {
+    Critical = "Critical",
+    Weak = "Weak",
+    Medium = "Medium",
+    Strong = "Strong"
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    calculateStrength: {
+        type: import('vue').PropType<(password: string) => number>;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    calculateStrength: {
+        type: import('vue').PropType<(password: string) => number>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    calculateStrength: (password: string) => number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/components/RInputPassword/utils/input-password.props.d.ts

@@ -0,0 +1,8 @@
+import { PropType } from 'vue';
+declare const _default: {
+    calculateStrength: {
+        type: PropType<(password: string) => number>;
+        default: undefined;
+    };
+};
+export default _default;

package/dist/src/components/RInputPassword/utils/input-password.style.d.ts

@@ -0,0 +1,4 @@
+declare const meter: string;
+declare const strengthLabel: string;
+declare const wrapper: string;
+export { meter, strengthLabel, wrapper };

package/dist/src/components/RModal/RModal.d.ts

@@ -0,0 +1,65 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    closeCallback: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    fullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mode: {
+        type: import('vue').PropType<import('../../types').ModalMode>;
+        default: string;
+        validator(mode: import('../../types').ModalMode): boolean;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    preventClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "close"[], "close", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    closeCallback: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    fullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mode: {
+        type: import('vue').PropType<import('../../types').ModalMode>;
+        default: string;
+        validator(mode: import('../../types').ModalMode): boolean;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    preventClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    fullscreen: boolean;
+    mode: import('../../types').ModalMode;
+    title: string;
+    open: boolean;
+    closeCallback: Function;
+    preventClose: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/components/RModal/utils/modal.props.d.ts

@@ -0,0 +1,30 @@
+import { PropType } from 'vue';
+import { ModalMode } from '../../../types';
+declare const _default: {
+    closeCallback: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    fullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mode: {
+        type: PropType<ModalMode>;
+        default: string;
+        validator(mode: ModalMode): boolean;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    preventClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export default _default;

package/dist/src/components/RModal/utils/modal.style.d.ts

@@ -0,0 +1,3 @@
+declare const modal: string;
+declare const modalHeader: string;
+export { modal, modalHeader };

package/dist/src/components/RRadio/RRadio.d.ts

@@ -0,0 +1,60 @@
+import { SlotsType, VNode } from 'vue';
+interface Slots {
+    label?: () => VNode[];
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    placement: {
+        type: import('vue').PropType<import('../../types').Placement>;
+        default: import('../../types').Placement;
+        validator: (placement: import('../../types').Placement) => boolean;
+    };
+    radius: {
+        type: import('vue').PropType<import('../../types').Rounded>;
+        default: import('../../types').Rounded;
+        validator: (radii: import('../../types').Rounded) => boolean;
+    };
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    placement: {
+        type: import('vue').PropType<import('../../types').Placement>;
+        default: import('../../types').Placement;
+        validator: (placement: import('../../types').Placement) => boolean;
+    };
+    radius: {
+        type: import('vue').PropType<import('../../types').Rounded>;
+        default: import('../../types').Rounded;
+        validator: (radii: import('../../types').Rounded) => boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    radius: import('../../types').Rounded;
+    placement: import('../../types').Placement;
+    modelValue: string;
+}, SlotsType<Slots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/components/RRadio/utils/radio.props.d.ts

@@ -0,0 +1,27 @@
+import { PropType } from 'vue';
+import { Placement, Rounded } from '../../../types';
+declare const _default: {
+    value: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: Placement;
+        validator: (placement: Placement) => boolean;
+    };
+    radius: {
+        type: PropType<Rounded>;
+        default: Rounded;
+        validator: (radii: Rounded) => boolean;
+    };
+};
+export default _default;

package/dist/src/components/RRadio/utils/radio.style.d.ts

@@ -0,0 +1,64 @@
+declare const wrapper: import('../../../../styled-system/types').RecipeRuntimeFn<{
+    placement: {
+        before: {
+            flexDirection: "row-reverse";
+        };
+        after: {
+            flexDirection: "row";
+        };
+        hidden: {};
+    };
+}>;
+declare const input: import('../../../../styled-system/types').RecipeRuntimeFn<{
+    radius: {
+        sharp: {
+            borderRadius: "sharp";
+            _checked: {
+                '&::after': {
+                    borderRadius: "sharp";
+                };
+            };
+        };
+        xs: {
+            borderRadius: "xs";
+            _checked: {
+                '&::after': {
+                    borderRadius: "xs";
+                };
+            };
+        };
+        sm: {
+            borderRadius: "sm";
+            _checked: {
+                '&::after': {
+                    borderRadius: "sm";
+                };
+            };
+        };
+        md: {
+            borderRadius: "md";
+            _checked: {
+                '&::after': {
+                    borderRadius: "md";
+                };
+            };
+        };
+        lg: {
+            borderRadius: "lg";
+            _checked: {
+                '&::after': {
+                    borderRadius: "lg";
+                };
+            };
+        };
+        pill: {
+            borderRadius: "pill";
+            _checked: {
+                '&::after': {
+                    borderRadius: "pill";
+                };
+            };
+        };
+    };
+}>;
+export { input, wrapper };

package/dist/src/components/RRadioGroup/RRadioGroup.d.ts

@@ -0,0 +1,78 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    legend: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    name: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    orientation: {
+        type: import('vue').PropType<import('../../types').Orientation>;
+        default: import('../../types').Orientation;
+        validator: (orientation: import('../../types').Orientation) => boolean;
+    };
+    placement: {
+        type: import('vue').PropType<import('../../types').Placement>;
+        default: import('../../types').Placement;
+        validator: (placement: import('../../types').Placement) => boolean;
+    };
+    radius: {
+        type: import('vue').PropType<import('../../types').Rounded>;
+        default: import('../../types').Rounded;
+        validator: (radii: import('../../types').Rounded) => boolean;
+    };
+    variant: {
+        type: import('vue').PropType<import('../../types').RadioGroupType>;
+        default: import('../../types').RadioGroupType;
+        validator: (variant: import('../../types').RadioGroupType) => boolean;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    legend: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    name: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    orientation: {
+        type: import('vue').PropType<import('../../types').Orientation>;
+        default: import('../../types').Orientation;
+        validator: (orientation: import('../../types').Orientation) => boolean;
+    };
+    placement: {
+        type: import('vue').PropType<import('../../types').Placement>;
+        default: import('../../types').Placement;
+        validator: (placement: import('../../types').Placement) => boolean;
+    };
+    radius: {
+        type: import('vue').PropType<import('../../types').Rounded>;
+        default: import('../../types').Rounded;
+        validator: (radii: import('../../types').Rounded) => boolean;
+    };
+    variant: {
+        type: import('vue').PropType<import('../../types').RadioGroupType>;
+        default: import('../../types').RadioGroupType;
+        validator: (variant: import('../../types').RadioGroupType) => boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    legend: string;
+    variant: import('../../types').RadioGroupType;
+    radius: import('../../types').Rounded;
+    placement: import('../../types').Placement;
+    orientation: import('../../types').Orientation;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/components/RRadioGroup/utils/radio-group.props.d.ts

@@ -0,0 +1,37 @@
+import { PropType } from 'vue';
+import { Orientation, Placement, RadioGroupType, Rounded } from '../../../types';
+declare const _default: {
+    legend: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    name: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    orientation: {
+        type: PropType<Orientation>;
+        default: Orientation;
+        validator: (orientation: Orientation) => boolean;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: Placement;
+        validator: (placement: Placement) => boolean;
+    };
+    radius: {
+        type: PropType<Rounded>;
+        default: Rounded;
+        validator: (radii: Rounded) => boolean;
+    };
+    variant: {
+        type: PropType<RadioGroupType>;
+        default: RadioGroupType;
+        validator: (variant: RadioGroupType) => boolean;
+    };
+};
+export default _default;

package/dist/src/components/RRadioGroup/utils/radio-group.style.d.ts

@@ -0,0 +1,35 @@
+declare const group: import('../../../../styled-system/types').RecipeRuntimeFn<{
+    orientation: {
+        horizontal: {
+            flexDirection: "row";
+        };
+        vertical: {
+            flexDirection: "column";
+        };
+    };
+    variant: {
+        list: {};
+        card: {
+            '& > label': {
+                border: "1px solid";
+                borderColor: "input.border";
+                borderRadius: "sm";
+            };
+            '& > label:has(input:checked)': {
+                borderColor: "primary.800";
+            };
+        };
+        grid: {
+            gap: "0";
+            overflow: "hidden";
+            border: "1px solid";
+            borderColor: "input.border";
+            borderRadius: "sm";
+            '& > label:has(input:checked)': {
+                backgroundColor: "primary.200";
+            };
+        };
+    };
+}>;
+declare const wrapper: import('../../../../styled-system/types').SystemStyleObject;
+export { group, wrapper };