@edvisor/product-language 0.7.0-rc1 → 0.7.0

package/lib/components/range-slider/components/handle.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties } from 'react';
+import { FC } from '@helpers';
+import { GetHandleProps, SliderItem } from 'react-compound-slider';
+interface IHandleComponent {
+    domain: number[];
+    handle: SliderItem;
+    classes?: CSSProperties;
+    thumbHeight: number;
+    getHandleProps: GetHandleProps;
+}
+export declare const HandleComponent: FC<IHandleComponent>;
+export {};

package/lib/components/range-slider/components/rail.d.ts

@@ -0,0 +1,9 @@
+import { FC } from '@helpers';
+import { GetRailProps } from 'react-compound-slider';
+interface IRailComponent {
+    getRailProps: GetRailProps;
+    trackHeight: number;
+    thumbHeight: number;
+}
+export declare const RailComponent: FC<IRailComponent>;
+export {};

package/lib/components/range-slider/components/slider-component.d.ts

@@ -0,0 +1,12 @@
+import { FC } from '@helpers';
+import { SliderType } from '../types';
+interface IProps {
+    mode: 1 | 2 | 3;
+    domain: number[];
+    values: ReadonlyArray<number>;
+    type: SliderType;
+    onChange: (values: ReadonlyArray<number>) => void;
+    onUpdate?: (values: ReadonlyArray<number>) => void;
+}
+export declare const SliderComponent: FC<IProps>;
+export {};

package/lib/components/range-slider/components/slider-inputs.d.ts

@@ -0,0 +1,14 @@
+import { FC } from '@helpers';
+import { SliderType } from '../types';
+interface ISliderInputs {
+    onChange: (range: number[]) => void;
+    range: ReadonlyArray<number>;
+    minValue: number;
+    maxValue: number;
+    maxLabel?: string;
+    minLabel?: string;
+    type: SliderType;
+    prefix?: string;
+}
+export declare const SliderInputs: FC<ISliderInputs>;
+export {};

package/lib/components/range-slider/components/tick.d.ts

@@ -0,0 +1,10 @@
+import { FC } from '@helpers';
+import { ReactNode } from 'react';
+import { SliderItem } from 'react-compound-slider';
+interface ITickComponent {
+    tick: SliderItem;
+    count: number;
+    format?: (value: number) => ReactNode;
+}
+export declare const TickComponent: FC<ITickComponent>;
+export {};

package/lib/components/range-slider/components/track.d.ts

@@ -0,0 +1,11 @@
+import { FC } from '@helpers';
+import { GetTrackProps, SliderItem } from 'react-compound-slider';
+interface ITrackComponent {
+    source: SliderItem;
+    target: SliderItem;
+    trackHeight: number;
+    thumbHeight: number;
+    getTrackProps: GetTrackProps;
+}
+export declare const TrackComponent: FC<ITrackComponent>;
+export {};

package/lib/components/range-slider/index.d.ts

@@ -0,0 +1,2 @@
+export * from './range-slider';
+export * from './slider';

package/lib/components/range-slider/range-slider.d.ts

@@ -0,0 +1,15 @@
+import { FC } from '@helpers';
+interface IRangeSlider {
+    data?: number[];
+    editable?: boolean;
+    prefix?: string;
+    min?: number;
+    max?: number;
+    graphHeight?: number;
+    maxLabel?: string;
+    minLabel?: string;
+    values: number[];
+    onChange?: (value: number[]) => void;
+}
+export declare const RangeSlider: FC<IRangeSlider>;
+export {};

package/lib/components/range-slider/slider.d.ts

@@ -0,0 +1,11 @@
+import { FC } from '@helpers';
+interface ISlider {
+    min?: number;
+    max: number;
+    value: number;
+    prefix?: string;
+    editable?: boolean;
+    onChange?: (value: number) => void;
+}
+export declare const Slider: FC<ISlider>;
+export {};

package/lib/components/range-slider/types.d.ts

@@ -0,0 +1,11 @@
+export declare enum SliderType {
+    SLIDER = 0,
+    RANGE_SLIDER = 1
+}
+export declare enum ValueType {
+    MIN = 0,
+    MAX = 1
+}
+export declare const FieldContainer: import("styled-components").StyledComponent<"div", any, {
+    margin: string;
+}, never>;

package/lib/components/select/components/menu-container.d.ts

@@ -0,0 +1,3 @@
+import { FC } from '@helpers';
+import { IMenuContainerProps } from '../types';
+export declare const MenuContainer: FC<IMenuContainerProps>;

package/lib/components/select/components/menu-list.d.ts

@@ -0,0 +1,3 @@
+import { FC } from '@helpers';
+import { IMenuComponentProps } from '../types';
+export declare const MenuList: FC<IMenuComponentProps>;

package/lib/components/select/components/menu-row.d.ts

@@ -0,0 +1,9 @@
+import { CSSProperties } from 'react';
+import { IMenuComponentProps } from '../types';
+interface IMenuRowProps {
+    index: number;
+    style: CSSProperties;
+    data: IMenuComponentProps;
+}
+export declare const MenuRow: import("react").MemoExoticComponent<({ index, style, data }: IMenuRowProps) => JSX.Element>;
+export {};

package/lib/components/select/components/menu.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { IMenuComponentProps } from '../types';
+export declare const Menu: (props: IMenuComponentProps) => JSX.Element;

package/lib/components/select/components/option.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { IOptionComponentProps } from '../types';
+interface IOptionItemProps {
+    active?: IOptionComponentProps['active'];
+    selected?: IOptionComponentProps['selected'];
+    height?: IOptionComponentProps['height'];
+}
+export declare const OptionItem: import("styled-components").StyledComponent<"div", any, {
+    column?: boolean | undefined;
+    center?: boolean | undefined;
+} & IOptionItemProps, never>;
+export declare const OptionComponent: import("react").MemoExoticComponent<(props: IOptionComponentProps) => JSX.Element>;
+export {};

package/lib/components/select/components/select-label.d.ts

@@ -0,0 +1 @@
+export declare const SelectLabel: import("styled-components").StyledComponent<import("../../../helpers").FC<import("components/typography").ITextComponentProps & import("../../../foundations").ILabelProps, {}>, any, {}, never>;

package/lib/components/select/components/value-component-multi.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { IValueComponentMultiProps } from '../types';
+declare const _default: <T>(props: IValueComponentMultiProps<T>) => JSX.Element;
+export default _default;

package/lib/components/select/components/value-component-single.d.ts

@@ -0,0 +1,4 @@
+import { IValueComponentSingleProps } from '../types';
+import { FC } from '@helpers';
+declare const _default: FC<IValueComponentSingleProps<any>, {}>;
+export default _default;

package/lib/components/select/components/value.d.ts

@@ -0,0 +1,4 @@
+import { FC } from '@helpers';
+import { IValueProps } from '../types';
+declare const _default: FC<IValueProps, {}>;
+export default _default;

package/lib/components/select/index.d.ts

@@ -0,0 +1,3 @@
+export * from './select';
+export * from './components/menu-list';
+export { IOption } from './types';

package/lib/components/select/select.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { PropsWithChildren } from '@helpers';
+import { ISelectProps } from './types';
+declare const SelectImpl: <T>(props: ISelectProps<T>, selectRef: React.ForwardedRef<HTMLDivElement>) => JSX.Element;
+export declare const Select: <T>(props: ISelectProps<T> & {
+    children?: import("react").ReactNode;
+} & {
+    ref?: import("react").ForwardedRef<HTMLDivElement> | undefined;
+}) => ReturnType<typeof SelectImpl>;
+export {};

package/lib/components/select/types.d.ts

@@ -0,0 +1,133 @@
+import { FC } from '@helpers';
+import { CSSProperties } from 'react';
+export interface ISelectProps<T = any> {
+    className?: string;
+    style?: CSSProperties;
+    options?: IOption<T>[];
+    value?: T | T[];
+    placeholder?: string;
+    emptyText?: string;
+    clearable?: boolean;
+    searchable?: boolean;
+    disabled?: boolean;
+    multi?: boolean;
+    invalid?: boolean;
+    errors?: {
+        message: string;
+    }[];
+    rowHeight?: number;
+    menuHeight?: number;
+    menuPosition?: 'top' | 'bottom';
+    menuTitle?: string;
+    label?: string;
+    labelPosition?: 'top' | 'side';
+    labelComponent?: FC<LabelComponentProps<T>>;
+    menuComponent?: FC<IMenuComponentProps>;
+    onChange?(value: T[] | T | undefined, option?: IOption<T>): void;
+    onSearch?(value: string): void;
+    onOpen?(): void;
+    onClose?(): void;
+}
+export interface IValueProps {
+    options: ISelectProps['options'];
+    value: ISelectProps['value'];
+    placeholder: ISelectProps['placeholder'];
+    clearable: ISelectProps['clearable'];
+    searchable: ISelectProps['searchable'];
+    labelComponent: ISelectProps['labelComponent'];
+    multi: ISelectProps['multi'];
+    disabled: ISelectProps['disabled'];
+    invalid: ISelectProps['invalid'];
+    errors: ISelectProps['errors'];
+    search?: string;
+    open: boolean;
+    focused?: boolean;
+    label: ISelectProps['label'];
+    labelPosition: ISelectProps['labelPosition'];
+    onClear(): void;
+    onClick(): void;
+    onSearch(search: string): void;
+    onSearchFocus(): void;
+    onSearchBlur(): void;
+    onOptionRemove(value: any): void;
+}
+export interface IMenuContainerProps {
+    className?: string;
+    menuTop?: number;
+    menuHeight?: RectSize;
+    menuPosition?: ISelectProps['menuPosition'];
+    invalid?: boolean;
+    labelPosition?: string;
+    label?: string;
+    children?: React.ReactNode;
+    onRef?(el: HTMLDivElement | undefined): void;
+    onClick?(el: React.MouseEvent<HTMLDivElement>): void;
+}
+declare type RectSize = number | 'auto';
+export interface IValueComponentMultiProps<T = any> extends IValueComponentSingleProps<T> {
+    options: IOption<T>[];
+    onRemove(value: T): void;
+}
+export declare type LabelComponentProps<T = any> = IOption<T> & {
+    active: boolean;
+    type: 'value-single' | 'value-multi' | 'option';
+};
+export interface IValueComponentSingleProps<T = any> {
+    className?: string;
+    option: IOption<T>;
+    labelComponent: ISelectProps['labelComponent'];
+}
+export interface IOptionComponentProps<T extends IOption = any> {
+    className?: string;
+    option: T;
+    active?: boolean;
+    selected?: boolean;
+    height?: number;
+    labelComponent: ISelectProps['labelComponent'];
+    search?: string;
+    onSelect(value: T['value'], option?: T): void;
+}
+export interface IOption<T = any> {
+    value: T;
+    disabled?: boolean;
+    label: string;
+    [key: string]: any;
+}
+export interface IMenuComponentProps<T = any> {
+    options: ISelectProps['options'];
+    value: ISelectProps['value'];
+    labelComponent: ISelectProps['labelComponent'];
+    menuComponent: ISelectProps['menuComponent'];
+    emptyText: ISelectProps['emptyText'];
+    multi: ISelectProps['multi'];
+    rowHeight: ISelectProps['rowHeight'];
+    menuHeight: ISelectProps['menuHeight'];
+    menuPosition: ISelectProps['menuPosition'];
+    invalid: ISelectProps['invalid'];
+    selectedIndex?: number;
+    open: boolean;
+    search?: string;
+    labelPosition?: string;
+    label?: string;
+    menuTitle?: string;
+    onSelect(value: T extends any[] ? T[] : T, option?: T): void;
+}
+export interface IPosition {
+    menuPosition?: 'top' | 'bottom';
+    menuHeight?: RectSize;
+    label?: string;
+    labelPosition?: string;
+}
+export declare const DEFAULT_ROW_HEIGHT = 44;
+export declare const DEFAULT_MENU_HEIGHT = 190;
+export declare const DEFAULT_EMPTY_TEXT = "No results found";
+export declare const DEFAULT_PLACEHOLDER = "Select Something";
+export declare const enum menuPositionType {
+    TOP = "top",
+    BOTTOM = "bottom"
+}
+export declare const enum labelPositionType {
+    TOP = "top",
+    SIDE = "side"
+}
+export {};

package/lib/components/select/utils.d.ts

@@ -0,0 +1,15 @@
+import { IOption, IPosition } from './types';
+export declare function getDocument(): Document | undefined;
+export declare function equal(valueA: any, valueB: any): boolean;
+export declare function getValueOptions(options: IOption[], value: any, multi: boolean | undefined): IOption<any>[];
+export declare const keys: {
+    ARROW_UP: string;
+    ARROW_DOWN: string;
+    ENTER: string;
+    TAB: string;
+    ESC: string;
+    BACKSPACE: string;
+    SPACE: string;
+};
+export declare function toKey(value: any): string | number;
+export declare const topPosition: (props: IPosition) => string;

package/{src/lib/components/radio-button/index.tsx → lib/components/spinner/index.d.ts}

@@ -1 +1 @@
-export * from './radio-button'
+export * from './spinner';

package/lib/components/spinner/spinner-size-flags.d.ts

@@ -0,0 +1,10 @@
+import { MappedEnum, RequireOnlyOne, PropsWithChildren } from '@helpers';
+declare const enum SpinnerSize {
+    small = 1,
+    medium = 2,
+    large = 4
+}
+declare type SpinnerSizes<T> = MappedEnum<typeof SpinnerSize, T>;
+export declare type SpinnerProps = Partial<RequireOnlyOne<SpinnerSizes<boolean>>> & PropsWithChildren;
+export declare function getValuesBySize(props: SpinnerProps): string;
+export {};

package/lib/components/spinner/spinner.d.ts

@@ -0,0 +1,9 @@
+import { SpinnerProps } from './spinner-size-flags';
+import { FC } from '@helpers';
+declare type IProps = SpinnerProps & {
+    onPrimary?: boolean;
+    onCritical?: boolean;
+    className?: string;
+};
+export declare const Spinner: FC<IProps>;
+export {};

package/lib/components/tabs/components/index.d.ts

@@ -0,0 +1 @@
+export * from './tab';

package/lib/components/tabs/components/tab.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes } from 'react';
+import { FC, PropsWithChildren } from '@helpers';
+export interface ITabProps extends PropsWithChildren, HTMLAttributes<HTMLDivElement> {
+    Prefix?: FC<HTMLAttributes<HTMLElement>>;
+    selected?: boolean;
+}
+export declare const Tab: FC<ITabProps>;

package/lib/components/tabs/index.d.ts

@@ -0,0 +1 @@
+export * from './tabs';

package/lib/components/tabs/tabs.d.ts

@@ -0,0 +1,15 @@
+import { FC, PropsWithChildren, Slot, StylableSlot } from '@helpers';
+declare class Content extends StylableSlot {
+}
+declare class Navigation extends Slot {
+}
+declare type SubComponents = {
+    Content: typeof Content;
+    TabList: typeof Navigation;
+};
+interface ITabsProps extends PropsWithChildren {
+    selected: number;
+    onChange?: (selected: number) => void;
+}
+export declare const Tabs: FC<ITabsProps, SubComponents>;
+export { Tab } from './components';

package/lib/components/tag/components/close-button.d.ts

@@ -0,0 +1,8 @@
+import { FC, PropsWithChildren } from '@helpers';
+import { HTMLAttributes } from 'react';
+interface IProps extends HTMLAttributes<HTMLDivElement>, PropsWithChildren {
+    disabled?: boolean;
+    onClick?: () => void;
+}
+export declare const CloseButton: FC<IProps>;
+export {};

package/lib/components/tag/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './close-button';
+export * from './tag-label';

package/lib/components/tag/components/tag-label.d.ts

@@ -0,0 +1,8 @@
+import { FC, PropsWithChildren } from '@helpers';
+import { HTMLAttributes } from 'react';
+interface IProps extends HTMLAttributes<HTMLLabelElement>, PropsWithChildren {
+    closable?: boolean;
+    disabled?: boolean;
+}
+export declare const TagLabel: FC<IProps>;
+export {};

package/lib/components/tag/index.d.ts

@@ -0,0 +1 @@
+export * from './tag';

package/lib/components/tag/tag.d.ts

@@ -0,0 +1,10 @@
+import { FC, PropsWithChildren } from '@helpers';
+import { HTMLAttributes } from 'react';
+interface IProps extends HTMLAttributes<HTMLDivElement>, PropsWithChildren {
+    closable?: boolean;
+    disabled?: boolean;
+    className?: string;
+    onClick?: () => void;
+}
+export declare const Tag: FC<IProps>;
+export {};

package/lib/components/thumbnail/index.d.ts

@@ -0,0 +1 @@
+export * from './thumbnail';

package/lib/components/thumbnail/thumbnail-size-flags.d.ts

@@ -0,0 +1,10 @@
+import { MappedEnum, RequireOnlyOne, PropsWithChildren } from '@helpers';
+declare const enum ThumbnailSize {
+    small = 1,
+    medium = 2,
+    large = 4
+}
+declare type ThumbnailSizes<T> = MappedEnum<typeof ThumbnailSize, T>;
+export declare type ThumbnailSizeProps = Partial<RequireOnlyOne<ThumbnailSizes<boolean>>> & PropsWithChildren;
+export declare function getValuesBySize(props: ThumbnailSizeProps): string;
+export {};

package/lib/components/thumbnail/thumbnail.d.ts

@@ -0,0 +1,10 @@
+import { FC } from '@helpers';
+import { ThumbnailSizeProps } from './thumbnail-size-flags';
+interface IThumbnailProps {
+    imageUrl?: string;
+    imageLabel?: string;
+    className?: string;
+}
+declare type IProps = IThumbnailProps & ThumbnailSizeProps;
+export declare const Thumbnail: FC<IProps>;
+export {};

package/lib/components/tree-view/components/tree-node.d.ts

@@ -0,0 +1,3 @@
+import { FC, PropsWithChildren } from '@helpers';
+import { ITreeNode } from '../types';
+export declare const TreeNode: FC<PropsWithChildren<ITreeNode>>;

package/lib/components/tree-view/helper.d.ts

@@ -0,0 +1,12 @@
+import { INode, IFlattenNode, CheckboxState } from './types';
+export declare const flattenNodes: (flattenList: IFlattenNode[], nodes: INode[], parent?: INode, depth?: number) => void;
+export declare const getNode: (nodes: IFlattenNode[], value: string) => IFlattenNode | undefined;
+export declare const deserializeList: (flatNodes: IFlattenNode[], lists: {
+    checked: string[];
+    expanded: string[];
+}) => void;
+export declare const serializeList: (flatNodes: IFlattenNode[], key: string) => string[];
+export declare const expandAllNodes: (flatNodes: IFlattenNode[], expand: boolean) => void;
+export declare const toggleChecked: (flatNodes: IFlattenNode[], node: INode, isChecked: boolean) => void;
+export declare const toggleNode: (flatNodes: IFlattenNode[], nodeValue: string, key: string, toggleValue: boolean) => void;
+export declare const getNodeCheckState: (flattenNodeList: IFlattenNode[], node: INode) => CheckboxState;

package/lib/components/tree-view/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tree-view';
+export { INode, ICheckNode, IExpandNode } from './types';

package/lib/components/tree-view/tree-view.d.ts

@@ -0,0 +1,3 @@
+import { FC, PropsWithChildren } from '@helpers';
+import { ITreeViewProps } from './types';
+export declare const TreeView: FC<PropsWithChildren<ITreeViewProps>>;

package/lib/components/tree-view/types.d.ts

@@ -0,0 +1,63 @@
+import { ReactNode } from 'react';
+export interface INode {
+    label: string;
+    value: string;
+    helpfulMessage?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    children?: INode[];
+}
+export interface IFlattenNode extends INode {
+    parent?: INode;
+    isChild: boolean;
+    isParent: boolean;
+    isLeaf: boolean;
+    treeDepth: number;
+    index: number;
+    checked: boolean;
+    checkState: number;
+    expanded: boolean;
+}
+export interface ITreeViewProps {
+    checkedList: string[];
+    nodes: INode[];
+    expanded?: string[];
+    className?: string;
+    title?: string;
+    useCardContainer?: boolean;
+    showChildCount?: boolean;
+    expandDisabled?: boolean;
+    onCheck: (checked: string[], node?: ICheckNode) => void;
+    onClick?: (node: ICheckNode) => void;
+    onExpand?: (expanded: string[], node?: IExpandNode) => void;
+}
+export interface ITreeNode {
+    checkState: number;
+    disabled: boolean;
+    expanded: boolean;
+    isParent: boolean;
+    isLeaf: boolean;
+    expandDisabled: boolean;
+    label: string;
+    value: string;
+    children: ReactNode;
+    treeId: string;
+    invalid: boolean;
+    childCount: number;
+    showChildCount: boolean;
+    helpfulMessage?: string;
+    onCheck: (node: ICheckNode) => void;
+    onClick: (node: ICheckNode) => void;
+    onExpand: (node: IExpandNode) => void;
+}
+export interface ICheckNode extends INode {
+    checked: boolean;
+}
+export interface IExpandNode extends INode {
+    expanded: boolean;
+}
+export declare enum CheckboxState {
+    UNCHECKED = 0,
+    CHECKED = 1,
+    INDETERMINATE = 2
+}

package/lib/components/typography/index.d.ts

@@ -0,0 +1 @@
+export * from './typography';

package/lib/components/typography/typography.d.ts

@@ -0,0 +1,24 @@
+import { HTMLAttributes } from 'react';
+import { IBodyProps, ILabelProps } from '@foundations';
+import { FC, PropsWithChildren } from '@helpers';
+import { ITextAspectProps, ITransientTextAspectProps } from 'foundations/typography/text-aspect-flags';
+export declare type ITextComponentProps = ITextAspectProps & {
+    emphasis?: boolean;
+} & HTMLAttributes<HTMLElement> & PropsWithChildren;
+declare type ITransientTextComponentProps = ITransientTextAspectProps & {
+    $emphasis?: boolean;
+} & HTMLAttributes<HTMLElement>;
+export declare const Display: FC<ITextComponentProps>;
+export declare const Heading1: FC<ITextComponentProps>;
+export declare const Heading2: FC<ITextComponentProps>;
+export declare const Heading3: FC<ITextComponentProps>;
+export declare const Heading4: FC<ITextComponentProps>;
+export declare const BODY_LARGE: import("styled-components").StyledComponent<"div", any, {} & (ITransientTextComponentProps & IBodyProps), never>;
+export declare const BodyLarge: FC<ITextComponentProps & IBodyProps>;
+export declare const BODY: import("styled-components").StyledComponent<"div", any, {} & (ITransientTextComponentProps & IBodyProps), never>;
+export declare const Body: FC<ITextComponentProps & IBodyProps>;
+export declare const CAPTION: import("styled-components").StyledComponent<"div", any, {} & ITransientTextComponentProps, never>;
+export declare const Caption: FC<ITextComponentProps>;
+export declare const LABEL: import("styled-components").StyledComponent<"div", any, {} & (ITransientTextComponentProps & ILabelProps), never>;
+export declare const Label: FC<ITextComponentProps & ILabelProps>;
+export {};