@heliux-org/design-system-core 0.0.49 → 0.0.50

package/dist/mocked_classnames_esm/core/src/components/DatePicker/DateNavigationItem/DateNavigationItem.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+declare const ICONS: {
+    prev: React.FC<import("../../Icon/Icons/components/MoveArrowLeft").MoveArrowLeftProps>;
+    next: React.FC<import("../../Icon/Icons/components/MoveArrowRight").MoveArrowRightProps>;
+};
+export interface DateNavigationItemProps {
+    kind: keyof typeof ICONS;
+    onClick?: () => void;
+}
+declare const DateNavigationItem: ({ kind, onClick }: DateNavigationItemProps) => import("react/jsx-runtime").JSX.Element;
+export default DateNavigationItem;

package/dist/mocked_classnames_esm/core/src/components/DatePicker/DatePicker.d.ts

@@ -0,0 +1,36 @@
+import "react-dates/initialize";
+import "react-dates/lib/css/_datepicker.css";
+import { DayOfWeekShape } from "react-dates";
+import { Moment, RangeDate } from "./types";
+import VibeComponentProps from "../../types/VibeComponentProps";
+import VibeComponent from "../../types/VibeComponent";
+export interface DatePickerProps extends VibeComponentProps {
+    /** set the first day of the week to display */
+    firstDayOfWeek?: DayOfWeekShape;
+    /** current start date */
+    date?: Moment;
+    /** current end date */
+    endDate?: Moment;
+    /** on date selected callback */
+    onPickDate?: (date: Moment | RangeDate) => void;
+    /** hide the month navigations keys */
+    hideNavigationKeys?: boolean;
+    /** show days outside the cuurent month view */
+    enableOutsideDays?: boolean;
+    /** show week number column */
+    showWeekNumber?: boolean;
+    /** set the size of single day element */
+    daySize?: number;
+    /** determine if day should be disabled */
+    shouldBlockDay?: (date: Moment) => boolean;
+    /** date range mode*/
+    range?: boolean;
+    /** number of month to display*/
+    numberOfMonths?: number;
+    /** determine if year should be disabled */
+    shouldBlockYear?: (year: number) => boolean;
+    /** determine if date range should be disabled */
+    shouldBlockRange?: (date: Moment) => boolean;
+}
+declare const DatePicker: VibeComponent<DatePickerProps, HTMLElement>;
+export default DatePicker;

package/dist/mocked_classnames_esm/core/src/components/DatePicker/DatePickerHeader/DatePickerHeader.d.ts

@@ -0,0 +1,10 @@
+import { Moment } from "../types";
+export interface DatePickerHeaderProps {
+    currentDate: Moment;
+    isMonthYearSelection: boolean;
+    onToggleMonthYearPicker: () => void;
+    hideNavigationKeys: boolean;
+    "data-testid"?: string;
+}
+declare const DatePickerHeader: (props: DatePickerHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export default DatePickerHeader;

package/dist/mocked_classnames_esm/core/src/components/DatePicker/YearPicker/YearPicker.d.ts

@@ -0,0 +1,9 @@
+import { Moment } from "../types";
+export interface YearPickerProps {
+    selectedDate?: Moment;
+    isYearBlocked?: (year: number) => boolean;
+    changeCurrentDate: (date: Moment) => void;
+    "data-testid"?: string;
+}
+declare const YearPicker: ({ selectedDate, isYearBlocked, changeCurrentDate, "data-testid": dateTestId, }: YearPickerProps) => import("react/jsx-runtime").JSX.Element;
+export default YearPicker;

package/dist/mocked_classnames_esm/core/src/components/DatePicker/YearPicker/YearsList.d.ts

@@ -0,0 +1,8 @@
+export interface YearsListProps {
+    yearsItems: number[];
+    isYearBlocked?: (year: number) => boolean;
+    onSelect: (year: number) => void;
+    selectedYear: string;
+}
+declare const YearsList: ({ yearsItems, isYearBlocked, onSelect, selectedYear, }: YearsListProps) => import("react/jsx-runtime").JSX.Element;
+export default YearsList;

package/dist/mocked_classnames_esm/core/src/components/DatePicker/__tests__/DatePicker.jest.d.ts

@@ -0,0 +1,2 @@
+export declare function getFirstDayOfMonthElement(container: HTMLElement): Element;
+export declare function getNextWeekFirstDayElement(pivotElement: HTMLElement): Element;

package/dist/mocked_classnames_esm/core/src/components/DatePicker/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const YEAR_FORMAT = "YYYY";
+export declare const MONTH_FORMAT = "MMMM";
+export declare const DAY_SIZE = 40;
+export declare const WEEK_FIRST_DAY = 1;

package/dist/mocked_classnames_esm/core/src/components/DatePicker/date-picker-utils.d.ts

@@ -0,0 +1 @@
+export declare const calcNewYearsPage: (firstYearInPage: number, pageSize: number) => number[];

package/dist/mocked_classnames_esm/core/src/components/DatePicker/types.d.ts

@@ -0,0 +1,14 @@
+import moment from "moment";
+export type Moment = moment.Moment;
+export declare enum FocusInput {
+    startDate = "startDate",
+    endDate = "endDate"
+}
+export declare enum Direction {
+    next = "next",
+    prev = "prev"
+}
+export interface RangeDate {
+    startDate: Moment | null;
+    endDate: Moment | null;
+}

package/dist/mocked_classnames_esm/core/src/components/Dialog/Dialog.d.ts

@@ -0,0 +1,229 @@
+import React, { PureComponent, ReactElement } from "react";
+import { Modifier } from "react-popper";
+import { DialogPosition } from "../../constants/positions";
+import { NOOP } from "../../utils/function-utils";
+import { AnimationType, HideShowEvent } from "../../constants/dialog";
+import { VibeComponentProps } from "../../types";
+import * as PopperJS from "@popperjs/core";
+export interface DialogProps extends VibeComponentProps {
+    /**
+     * A Classname to be added to <span> element which wraps the children
+     */
+    referenceWrapperClassName?: string;
+    /**
+     * Where the dialog should be in reference to the children,
+     * Top, Left, Right, Bottom ...
+     */
+    position?: DialogPosition;
+    /**
+     * PopperJS Modifiers type
+     * https://popper.js.org/docs/v2/modifiers/
+     */
+    modifiers?: Modifier<any>[];
+    startingEdge?: string;
+    /**
+     * How much to move the dialog in relative to children
+     * main is the axis in which the position is aligned to
+     * secondary is the vertical axes to the position
+     */
+    moveBy?: {
+        main?: number;
+        secondary?: number;
+    };
+    /**
+     * how much delay should the Dialog wait until it should trigger the show in MS
+     */
+    showDelay?: number;
+    /**
+     * how much delay should the Dialog wait until it should trigger the hide in MS
+     */
+    hideDelay?: number;
+    /**
+     * an array of hide/show trigger -
+     * Dialog.hideShowTriggers
+     */
+    showTrigger?: HideShowEvent | HideShowEvent[];
+    /**
+     * an array of hide/show trigger -
+     * Dialog.hideShowTriggers
+     */
+    hideTrigger?: HideShowEvent | HideShowEvent[];
+    /**
+     * If true, prevents open Dialog from closing on mouseEnter and closes Dialog, when  mouse leaves it
+     */
+    showOnDialogEnter?: boolean;
+    /**
+     * Show the Dialog when the children are mounting
+     */
+    shouldShowOnMount?: boolean;
+    /**
+     * disable the opening of the dialog
+     */
+    disable?: boolean;
+    /**
+     * open is a controlled prop to open the dialog
+     */
+    open?: boolean;
+    /**
+     * used when state is derived from props
+     */
+    isOpen?: boolean;
+    /**
+     * if this class exists on the children the show trigger will be ignored
+     */
+    showTriggerIgnoreClass?: string | Array<string>;
+    /**
+     * if this class exists on the children the hide trigger will be ignored
+     */
+    hideTriggerIgnoreClass?: string | Array<string>;
+    /**
+     * Dialog animation type
+     */
+    animationType?: AnimationType;
+    /**
+     * Classname to be added to the content container
+     */
+    wrapperClassName?: string;
+    /**
+     * Prevent Animation
+     */
+    preventAnimationOnMount?: boolean;
+    /**
+     * the container selector in which to append the dialog
+     * for examples: "body" , ".my-class", "#my-id"
+     */
+    containerSelector?: string;
+    /**
+     * should position the tooltip element
+     * https://popper.js.org/docs/v2/modifiers/arrow/
+     */
+    tooltip?: boolean;
+    /**
+     * class name to add to the tooltip element
+     */
+    tooltipClassName?: string;
+    /**
+     * callback to be called when the dialog is shown
+     */
+    onDialogDidShow?: () => void;
+    /**
+     * callback to be called when the dialog is hidden
+     */
+    onDialogDidHide?: (event: DialogEvent, eventName: HideShowEvent | string) => void;
+    /**
+     * callback to be called when click outside is being triggered
+     */
+    onClickOutside?: (event: React.MouseEvent) => void;
+    /**
+     * callback to be called when click on the content is being triggered
+     */
+    onContentClick?: (event: React.MouseEvent) => void;
+    /**
+     * z-index to add to the dialog
+     */
+    zIndex?: number;
+    useDerivedStateFromProps?: boolean;
+    /**
+     * Make the dialog disappear when the element it is attached to becomes hidden
+     */
+    hideWhenReferenceHidden?: boolean;
+    /**
+     * @deprecated - use shouldCallbackOnMount instead
+     */
+    shoudlCallbackOnMount?: boolean;
+    shouldCallbackOnMount?: boolean;
+    instantShowAndHide?: boolean;
+    getDynamicShowDelay?: () => {
+        showDelay: number;
+        preventAnimation: boolean;
+    };
+    content?: (() => JSX.Element) | JSX.Element;
+    /**
+     * The element where we will position the dialog beside.
+     */
+    children?: ReactElement | ReactElement[] | string;
+    /**
+     * Treats keyboard focus/blur events as mouse-enter/mouse-leave events
+     */
+    addKeyboardHideShowTriggersByDefault?: boolean;
+    /**
+     * If true disable the scroll for the containerSelector element.
+     * If string use it as selector to prevent scroll.
+     */
+    disableContainerScroll?: boolean | string;
+}
+export interface DialogState {
+    isOpen?: boolean;
+    shouldUseDerivedStateFromProps?: boolean;
+    preventAnimation?: boolean;
+}
+export type DialogEvent = React.MouseEvent | React.KeyboardEvent | KeyboardEvent | React.FocusEvent | CustomEvent;
+export default class Dialog extends PureComponent<DialogProps, DialogState> {
+    static hideShowTriggers: typeof HideShowEvent;
+    static positions: typeof DialogPosition;
+    static animationTypes: typeof AnimationType;
+    static defaultProps: {
+        position: string;
+        modifiers: (import("react-popper").StrictModifier<any> | Partial<PopperJS.Modifier<any, object>>)[];
+        moveBy: {
+            main: number;
+            secondary: number;
+        };
+        showDelay: number;
+        hideDelay: number;
+        showTrigger: HideShowEvent;
+        hideTrigger: HideShowEvent;
+        showOnDialogEnter: boolean;
+        shouldShowOnMount: boolean;
+        disable: boolean;
+        open: boolean;
+        animationType: AnimationType;
+        preventAnimationOnMount: boolean;
+        containerSelector: string;
+        tooltip: boolean;
+        onDialogDidShow: typeof NOOP;
+        onDialogDidHide: typeof NOOP;
+        onClickOutside: typeof NOOP;
+        onContentClick: typeof NOOP;
+        useDerivedStateFromProps: boolean;
+        hideWhenReferenceHidden: boolean;
+        shoudlCallbackOnMount: boolean;
+        shouldCallbackOnMount: boolean;
+        instantShowAndHide: boolean;
+        addKeyboardHideShowTriggersByDefault: boolean;
+    };
+    private showTimeout;
+    private hideTimeout;
+    constructor(props: DialogProps);
+    closeDialogOnEscape(event: KeyboardEvent): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    static getDerivedStateFromProps(nextProps: DialogProps, state: DialogState): DialogState;
+    getContainer(): Element;
+    showDialog(options?: {
+        preventAnimation?: boolean;
+    }): void;
+    onShowDialog(): void;
+    showDialogIfNeeded(options?: {}): void;
+    hideDialog(event: DialogEvent, eventName: HideShowEvent | string): void;
+    onHideDialog(event: DialogEvent, eventName: HideShowEvent | string): void;
+    hideDialogIfNeeded(event: DialogEvent, eventName: HideShowEvent | string): void;
+    handleEvent(eventName: HideShowEvent, target: EventTarget, event: DialogEvent): void;
+    isShown(): boolean;
+    isShowTrigger(eventName: HideShowEvent): boolean;
+    isHideTrigger(eventName: HideShowEvent): boolean;
+    onMouseEnter(e: React.MouseEvent): void;
+    onMouseLeave(e: React.MouseEvent): void;
+    onClick(e: React.MouseEvent): void;
+    onKeyDown(event: React.KeyboardEvent): void;
+    onMouseDown(e: React.MouseEvent): void;
+    onFocus(e: React.FocusEvent): void;
+    onBlur(e: React.FocusEvent): void;
+    onEsc(e: React.KeyboardEvent): void;
+    onContextMenu(e: React.MouseEvent): void;
+    onClickOutside(event: React.MouseEvent): void;
+    onDialogEnter(): void;
+    onDialogLeave(event: React.MouseEvent): void;
+    onContentClick(e: React.MouseEvent): void;
+    render(): string | React.ReactElement<any, string | React.JSXElementConstructor<any>>[] | import("react/jsx-runtime").JSX.Element;
+}

package/dist/mocked_classnames_esm/core/src/components/Dialog/DialogContent/DialogContent.d.ts

@@ -0,0 +1,31 @@
+import React, { CSSProperties, ReactElement } from "react";
+import { HideShowEvent } from "../consts/dialog-show-hide-event";
+import { VibeComponent, VibeComponentProps } from "../../../types";
+import * as PopperJS from "@popperjs/core";
+export interface DialogContentProps extends VibeComponentProps {
+    children?: ReactElement | ReactElement[];
+    position?: PopperJS.Placement;
+    wrapperClassName?: string;
+    isOpen?: boolean;
+    startingEdge?: any;
+    animationType?: string;
+    onEsc?: (event: React.KeyboardEvent) => void;
+    onMouseEnter?: (event: React.MouseEvent) => void;
+    onMouseLeave?: (event: React.MouseEvent) => void;
+    onClickOutside?: (event: React.MouseEvent, hideShowEvent: HideShowEvent) => void;
+    onClick?: (event: React.MouseEvent) => void;
+    showDelay?: number;
+    styleObject?: CSSProperties;
+    isReferenceHidden?: boolean;
+    hasTooltip?: boolean;
+    disableOnClickOutside?: boolean;
+    containerSelector?: string;
+    disableContainerScroll?: boolean | string;
+    /**
+     * On context menu event (right click) outside of the dialog
+     * @param e
+     */
+    onContextMenu?: (e: React.MouseEvent) => void;
+    "data-testid"?: string;
+}
+export declare const DialogContent: VibeComponent<DialogContentProps>;

package/dist/mocked_classnames_esm/core/src/components/Dialog/__stories__/Dialog.stories.helpers.d.ts

@@ -0,0 +1,4 @@
+export declare const TipDialogContentContainer: () => import("react/jsx-runtime").JSX.Element;
+export declare const TipDevTipPopperJs: () => import("react/jsx-runtime").JSX.Element;
+export declare const TipModal: () => import("react/jsx-runtime").JSX.Element;
+export declare const TipDevTipTechnicalPattern: () => import("react/jsx-runtime").JSX.Element;

package/dist/mocked_classnames_esm/core/src/components/Dialog/__stories__/helpers.d.ts

@@ -0,0 +1,6 @@
+import { FC } from "react";
+import "./Dialog.stories.scss";
+export interface ExampleContent {
+    rowsCount?: number;
+}
+export declare const ExampleContent: FC<ExampleContent>;

package/dist/mocked_classnames_esm/core/src/components/Dialog/__tests__/Dialog.interactions.d.ts

@@ -0,0 +1,2 @@
+import { interactionSuite } from "../../../tests/interactions-utils";
+export declare const closeTriggersInteractionSuite: ReturnType<typeof interactionSuite>;

package/dist/mocked_classnames_esm/core/src/components/Dialog/consts/dialog-show-hide-event.d.ts

@@ -0,0 +1,14 @@
+export declare enum HideShowEvent {
+    CLICK = "click",
+    CLICK_OUTSIDE = "clickoutside",
+    ESCAPE_KEY = "esckey",
+    TAB_KEY = "tab",
+    MOUSE_ENTER = "mouseenter",
+    MOUSE_LEAVE = "mouseleave",
+    ENTER = "enter",
+    MOUSE_DOWN = "mousedown",
+    FOCUS = "focus",
+    BLUR = "blur",
+    CONTENT_CLICK = "onContentClick",
+    CONTEXT_MENU = "contextmenu"
+}

package/dist/mocked_classnames_esm/core/src/components/DialogContentContainer/DialogContentContainer.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import { DialogSize, DialogType } from "./DialogContentContainerConstants";
+import { VibeComponentProps, VibeComponent } from "../../types";
+export interface DialogContentContainerProps extends VibeComponentProps {
+    children?: React.ReactNode;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+    type?: DialogType;
+    size?: DialogSize;
+    style?: React.CSSProperties;
+}
+declare const _default: ((VibeComponent<DialogContentContainerProps & React.RefAttributes<HTMLElement>, HTMLElement> & Partial<{
+    types: typeof DialogType;
+    sizes: typeof DialogSize;
+}>) | (React.FC<DialogContentContainerProps & React.RefAttributes<HTMLElement>> & Partial<{
+    types: typeof DialogType;
+    sizes: typeof DialogSize;
+}>)) & {
+    types: typeof DialogType;
+    sizes: typeof DialogSize;
+};
+export default _default;

package/dist/mocked_classnames_esm/core/src/components/DialogContentContainer/DialogContentContainerConstants.d.ts

@@ -0,0 +1,10 @@
+export declare enum DialogType {
+    MODAL = "modal",
+    POPOVER = "popover"
+}
+export declare enum DialogSize {
+    NONE = "none",
+    SMALL = "small",
+    MEDIUM = "medium",
+    LARGE = "large"
+}

package/dist/mocked_classnames_esm/core/src/components/DialogContentContainer/__stories__/DialogContentContainer.stories.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+declare const _default: {
+    title: string;
+    component: ((import("../../../types/VibeComponent").default<import("../DialogContentContainer").DialogContentContainerProps & import("react").RefAttributes<HTMLElement>, HTMLElement> & Partial<{
+        types: typeof import("../DialogContentContainerConstants").DialogType;
+        sizes: typeof import("../DialogContentContainerConstants").DialogSize;
+    }>) | (import("react").FC<import("../DialogContentContainer").DialogContentContainerProps & import("react").RefAttributes<HTMLElement>> & Partial<{
+        types: typeof import("../DialogContentContainerConstants").DialogType;
+        sizes: typeof import("../DialogContentContainerConstants").DialogSize;
+    }>)) & {
+        types: typeof import("../DialogContentContainerConstants").DialogType;
+        sizes: typeof import("../DialogContentContainerConstants").DialogSize;
+    };
+    argTypes: Partial<import("@storybook/types").ArgTypes<import("@storybook/types").Args>>;
+    decorators: import("@heliux-org/storybook-components/dist/functions/createStoryMetaSettings/types").Decorator[];
+};
+export default _default;
+export declare const Overview: {
+    render: any;
+    name: string;
+    args: {
+        children: import("react/jsx-runtime").JSX.Element;
+    };
+};
+export declare const Popover: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+    name: string;
+};
+export declare const Modal: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+    name: string;
+};

package/dist/mocked_classnames_esm/core/src/components/DialogContentContainer/__tests__/dialogContentContainer.jest.d.ts

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

package/dist/mocked_classnames_esm/core/src/components/Divider/Divider.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import { DirectionType, ColorType } from "./DividerConstants";
+import { VibeComponentProps } from "../../types";
+export interface DividerProps extends VibeComponentProps {
+    direction?: DirectionType;
+    color?: ColorType;
+    /**
+     * @deprecated - use className instead
+     */
+    classname?: string;
+    withoutMargin?: boolean;
+}
+declare const _default: ((import("../../types/VibeComponent").default<DividerProps, unknown> & Partial<{
+    directions: typeof DirectionType;
+    colors: typeof ColorType;
+}>) | (React.FC<DividerProps> & Partial<{
+    directions: typeof DirectionType;
+    colors: typeof ColorType;
+}>)) & {
+    directions: typeof DirectionType;
+    colors: typeof ColorType;
+};
+export default _default;

package/dist/mocked_classnames_esm/core/src/components/Divider/DividerConstants.d.ts

@@ -0,0 +1,8 @@
+export declare enum DirectionType {
+    VERTICAL = "vertical",
+    HORIZONTAL = "horizontal"
+}
+export declare enum ColorType {
+    DIVIDER_PRIMARY = "divider_primary",
+    DIVIDER_SECONDARY = "divider_secondary"
+}

package/dist/mocked_classnames_esm/core/src/components/Divider/__stories__/Divider.stories.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import { DividerProps } from "../Divider";
+declare const _default: {
+    title: string;
+    component: ((import("../../../types/VibeComponent").default<DividerProps, unknown> & Partial<{
+        directions: typeof import("../DividerConstants").DirectionType;
+        colors: typeof import("../DividerConstants").ColorType;
+    }>) | (import("react").FC<DividerProps> & Partial<{
+        directions: typeof import("../DividerConstants").DirectionType;
+        colors: typeof import("../DividerConstants").ColorType;
+    }>)) & {
+        directions: typeof import("../DividerConstants").DirectionType;
+        colors: typeof import("../DividerConstants").ColorType;
+    };
+    argTypes: Partial<import("@storybook/types").ArgTypes<import("@storybook/types").Args>>;
+    decorators: import("@heliux-org/storybook-components/dist/functions/createStoryMetaSettings/types").Decorator[];
+};
+export default _default;
+export declare const Overview: {
+    render: any;
+    name: string;
+};
+export declare const Directions: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+    name: string;
+};
+export declare const Colors: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+    name: string;
+};

package/dist/mocked_classnames_esm/core/src/components/Divider/__tests__/divider.jest.d.ts

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

package/dist/mocked_classnames_esm/core/src/components/Dropdown/__stories__/dropdown.stories.helpers.d.ts

@@ -0,0 +1 @@
+export declare const TipDevTipPopover: () => import("react/jsx-runtime").JSX.Element;

package/dist/mocked_classnames_esm/core/src/components/EditableHeading/EditableHeading.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+import { VibeComponent, VibeComponentProps } from "../../types";
+import { HeadingType, HeadingWeight } from "../Heading/HeadingConstants";
+import { EditableTypographyImplementationProps } from "../EditableTypography/EditableTypography";
+export interface EditableHeadingProps extends VibeComponentProps, EditableTypographyImplementationProps {
+    /**
+     * Sets the Heading type
+     * @type {HeadingType}
+     * */
+    type?: HeadingType;
+    /** Sets the Heading weight
+     * @type {HeadingWeight}
+     */
+    weight?: HeadingWeight;
+}
+declare const _default: ((VibeComponent<EditableHeadingProps & React.RefAttributes<HTMLElement>, HTMLElement> & Partial<{
+    types: typeof HeadingType;
+    weights: typeof HeadingWeight;
+}>) | (React.FC<EditableHeadingProps & React.RefAttributes<HTMLElement>> & Partial<{
+    types: typeof HeadingType;
+    weights: typeof HeadingWeight;
+}>)) & {
+    types: typeof HeadingType;
+    weights: typeof HeadingWeight;
+};
+export default _default;

package/dist/mocked_classnames_esm/core/src/components/EditableHeading/__stories__/EditableHeading.stories.helpers.d.ts

@@ -0,0 +1 @@
+export declare const TipEditableText: () => import("react/jsx-runtime").JSX.Element;

package/dist/mocked_classnames_esm/core/src/components/EditableHeading/__tests__/EditableHeading-interactions.d.ts

@@ -0,0 +1,2 @@
+import { interactionSuite } from "../../../tests/interactions-utils";
+export declare const overviewPlaySuite: ReturnType<typeof interactionSuite>;

package/dist/mocked_classnames_esm/core/src/components/EditableInput/EditableInput.d.ts

@@ -0,0 +1,42 @@
+import React from "react";
+import VibeComponent from "../../types/VibeComponent";
+import { VibeComponentProps } from "../../types";
+import { InputType } from "./EditableInputConstants";
+export interface EditableInputProps extends VibeComponentProps {
+    value?: string;
+    placeholder?: string;
+    inputType?: InputType;
+    autoSize?: boolean;
+    autoComplete?: boolean;
+    disabled?: boolean;
+    maxLength?: number;
+    shouldFocusOnMount?: boolean;
+    textareaSubmitOnEnter?: boolean;
+    ariaLabel?: string;
+    customColor?: string;
+    tabIndex?: number;
+    isValidValue?: (value: string) => boolean;
+    onFinishEditing?: (value: string, event: React.KeyboardEvent | React.FocusEvent) => void;
+    onArrowKeyDown?: (value: string, event: React.KeyboardEvent) => void;
+    onClick?: (event: React.MouseEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    onKeyPress?: () => void;
+    selectOnMount?: () => void;
+    ignoreBlurClass?: string;
+    onIgnoreBlurEvent?: (value: string) => void;
+    onFocus?: (event: React.FocusEvent) => void;
+    onBlur?: (event: React.FocusEvent) => void;
+    onCancelEditing?: (event: React.KeyboardEvent) => void;
+    onChange?: (value: string) => void;
+    onError?: () => void;
+    onSuccess?: () => void;
+    onKeyDown?: (event: React.KeyboardEvent, value: string) => void;
+    onTabHandler?: (value: string, event: React.KeyboardEvent) => void;
+}
+declare const _default: ((VibeComponent<EditableInputProps & React.RefAttributes<HTMLElement>, HTMLElement> & Partial<{
+    inputTypes: typeof InputType;
+}>) | (React.FC<EditableInputProps & React.RefAttributes<HTMLElement>> & Partial<{
+    inputTypes: typeof InputType;
+}>)) & {
+    inputTypes: typeof InputType;
+};
+export default _default;

package/dist/mocked_classnames_esm/core/src/components/EditableInput/EditableInputConstants.d.ts

@@ -0,0 +1,4 @@
+export declare enum InputType {
+    INPUT = "input",
+    TEXT_AREA = "textarea"
+}

package/dist/mocked_classnames_esm/core/src/components/EditableText/EditableText.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+import { VibeComponent, VibeComponentProps } from "../../types";
+import { EditableTypographyImplementationProps } from "../EditableTypography/EditableTypography";
+import { TextType, TextWeight } from "../Text/TextConstants";
+export interface EditableTextProps extends VibeComponentProps, EditableTypographyImplementationProps {
+    /**
+     * Sets the Text type
+     * @type {TextType}
+     * */
+    type?: TextType;
+    /** Sets the Text weight
+     * @type {TextWeight}
+     */
+    weight?: TextWeight;
+}
+declare const _default: ((VibeComponent<EditableTextProps & React.RefAttributes<HTMLElement>, HTMLElement> & Partial<{
+    types: typeof TextType;
+    weights: typeof TextWeight;
+}>) | (React.FC<EditableTextProps & React.RefAttributes<HTMLElement>> & Partial<{
+    types: typeof TextType;
+    weights: typeof TextWeight;
+}>)) & {
+    types: typeof TextType;
+    weights: typeof TextWeight;
+};
+export default _default;