@homecode/ui 4.11.1

package/dist/esm/types/src/components/Popup/Popup.helpers.d.ts

@@ -0,0 +1,8 @@
+type Id = number;
+export declare const childs: Record<Id, Id[]>;
+export declare const getId: () => number;
+export declare const getPopupId: (elem: any, attr?: string) => number;
+export declare function isLastChild(rootId: any, id: any): boolean;
+export declare function setChild(rootId: any, id: any): void;
+export declare function unsetChild(rootId: any, id: any): void;
+export {};

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

@@ -0,0 +1,34 @@
+import { DetailedHTMLProps, HTMLAttributes, ReactNode } from 'react';
+import { ComponentType, Size } from '../../types';
+export type TriggerPropsType = DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement> & {
+    className?: string;
+};
+export type WrapperPropsType = DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement> & {
+    className?: string;
+};
+export type Direction = 'top' | 'top-right' | 'top-left' | 'right' | 'right-top' | 'right-bottom' | 'bottom' | 'bottom-right' | 'bottom-left' | 'left' | 'left-top' | 'left-bottom';
+export type Props = ComponentType & {
+    isOpen?: boolean;
+    animated?: boolean;
+    hoverControl?: boolean;
+    focusControl?: boolean;
+    disabled?: boolean;
+    outlined?: boolean;
+    inline?: boolean;
+    paranja?: boolean;
+    blur?: boolean;
+    size?: Size;
+    elevation?: 1 | 2;
+    direction?: Direction;
+    trigger?: ReactNode;
+    triggerProps?: TriggerPropsType;
+    wrapperProps?: WrapperPropsType;
+    content: ReactNode;
+    contentProps?: any;
+    onOpen?: () => void;
+    onClose?: () => void;
+};
+export type State = {
+    isOpen: boolean;
+    isContentVisible: boolean;
+};

package/dist/esm/types/src/components/PopupMenu/PopupMenu.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import * as T from './PopupMenu.types';
+export declare function PopupMenu({ items, onClose, ...props }: T.Props): JSX.Element;

package/dist/esm/types/src/components/PopupMenu/PopupMenu.types.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import type { Props as ButtonProps } from '../Button/Button.types';
+import type { Props as PopupProps } from '../Popup/Popup.types';
+export type Item = Pick<ButtonProps, 'onClick'> & {
+    id: string;
+    title: ReactNode;
+    className?: string;
+};
+export type Props = Omit<PopupProps, 'content'> & {
+    trigger: ReactNode;
+    items: Item[];
+    onClose?: () => void;
+};

package/dist/esm/types/src/components/Portal/Portal.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+type Props = {
+    selector?: string;
+    children: React.ReactNode;
+};
+export declare function Portal(props: Props): import("react").ReactPortal;
+export {};

package/dist/esm/types/src/components/RequiredStar/RequiredStar.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import * as T from './RequiredStar.types';
+export declare function RequiredStar(props: T.Props): JSX.Element;

package/dist/esm/types/src/components/RequiredStar/RequiredStar.types.d.ts

@@ -0,0 +1,6 @@
+import { IconSize } from '../Icon/Icon.types';
+export type Props = {
+    className?: string;
+    size?: IconSize;
+    inline?: boolean;
+};

package/dist/esm/types/src/components/Router/Link/Link.d.ts

@@ -0,0 +1 @@
+export declare const Link: any;

package/dist/esm/types/src/components/Router/Link/Link.types.d.ts

@@ -0,0 +1,12 @@
+import { HTMLProps, MouseEvent } from 'react';
+import { ComponentType } from 'uilib/types';
+export type Props = HTMLProps<HTMLAnchorElement> & ComponentType & {
+    store?: any;
+    exactClassName?: string;
+    isPartialExact?: boolean;
+    isDisabled?: boolean;
+    disableExternalIcon?: boolean;
+    isClear?: boolean;
+    inline?: boolean;
+    onClick?: (e: MouseEvent<HTMLAnchorElement>, href: string) => void;
+};

package/dist/esm/types/src/components/Router/Redirect.d.ts

@@ -0,0 +1,5 @@
+import * as T from './Router.types';
+export declare const Redirect: {
+    (props: T.RedirectProps): any;
+    displayName: string;
+};

package/dist/esm/types/src/components/Router/Route.d.ts

@@ -0,0 +1,5 @@
+import * as T from './Router.types';
+export declare const Route: {
+    (props: T.RouteProps): any;
+    displayName: string;
+};

package/dist/esm/types/src/components/Router/Router.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const Router: any;
+export * from './Route';
+export * from './Redirect';
+export * from './Link/Link';
+export declare const RouterStore: any;
+export declare const RouterContext: import("react").Context<import("./context").ContextType>;

package/dist/esm/types/src/components/Router/Router.helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const replaceParamsInPath: (path: string, params: Record<string, string>) => string;
+export declare function parsePath(currPath: string, routePath: string, exact?: boolean): Record<string, string> | null;

package/dist/esm/types/src/components/Router/Router.types.d.ts

@@ -0,0 +1,18 @@
+import { Component, FC, ReactNode } from 'react';
+type AnyProps = Record<string, any>;
+type ComponentType = FC<AnyProps> | typeof Component<AnyProps>;
+export type RedirectProps = {
+    to: string;
+};
+export type RouteProps = {
+    path: string;
+    component: ComponentType;
+    exact?: boolean;
+} & Partial<RedirectProps>;
+export type Props = {
+    store?: any;
+    children: ReactNode;
+    basePath?: string;
+    single?: boolean;
+};
+export {};

package/dist/esm/types/src/components/Router/context.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export type ContextType = {
+    basePath: string;
+};
+declare const _default: import("react").Context<ContextType>;
+export default _default;

package/dist/esm/types/src/components/Router/store.d.ts

@@ -0,0 +1,2 @@
+declare const STORE: any;
+export default STORE;

package/dist/esm/types/src/components/Scroll/Scroll.d.ts

@@ -0,0 +1,67 @@
+import { Component } from 'react';
+import * as T from './Scroll.types';
+export declare class Scroll extends Component<T.Props> {
+    innerElem: HTMLDivElement;
+    onInnerRef: (elem: any) => void;
+    thumbELem: {
+        x: import("react").RefObject<HTMLDivElement>;
+        y: import("react").RefObject<HTMLDivElement>;
+    };
+    store: any;
+    isTouch: any;
+    timers: any;
+    currAxis: any;
+    pos: {
+        x: number;
+        y: number;
+    };
+    prevCoords: {
+        x: number;
+        y: number;
+    };
+    prevScrolls: {
+        x: number;
+        y: number;
+    };
+    prevBoundings: {
+        x: number;
+        y: number;
+    };
+    unsubscribeScrollHeightObserver: any;
+    static defaultProps: {
+        size: string;
+    };
+    constructor(props: any);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    eachAxis: (fn: any) => any[];
+    observeScrollHeight: () => void;
+    isScrollChanged(axis: any): boolean;
+    isBoudingsChanged(axis: any): boolean;
+    getoffsetSize: (axis: any) => any;
+    getInnerSize: (axis: any) => any;
+    getScrollSize: (axis: any) => any;
+    getScrollPos: (axis: any) => any;
+    getThumbSize: (axis: any) => any;
+    getOffset(axis: any): {
+        [x: string]: any;
+    };
+    getCoeffStyle: (axis: any) => string;
+    getPosStyle: (axis: any) => string;
+    updateAll: () => void;
+    update: (axis: any) => void;
+    updateCoeff(axis: any): void;
+    updatePos: (axis: any) => void;
+    updateScroll: (axis: any, e: any) => void;
+    dropScrollingState: any;
+    subscribePointerMoveUp: () => void;
+    unsubscribePointerMoveUp: () => void;
+    onDocScroll: (e: any) => void;
+    onInnerScroll: (e: any) => void;
+    onPointerDown: (axis: any, e: any) => void;
+    onPointerMove: (e: any) => void;
+    onPointerUp: (e: any) => void;
+    renderBar: (axis: any) => JSX.Element;
+    renderInner(): JSX.Element;
+    render(): JSX.Element;
+}

package/dist/esm/types/src/components/Scroll/Scroll.types.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode, HTMLAttributes } from 'react';
+import type { ComponentType, Size } from '../../types';
+type OffsetAxis = {
+    before?: number;
+    after?: number;
+};
+type Offset = {
+    x?: OffsetAxis;
+    y?: OffsetAxis;
+};
+export type Props = ComponentType & HTMLAttributes<HTMLDivElement> & {
+    innerClassName?: string;
+    thumbClassName?: string;
+    innerProps?: HTMLAttributes<HTMLDivElement>;
+    onInnerRef?: (ref: HTMLDivElement | null) => void;
+    extraWide?: boolean;
+    x?: boolean;
+    y?: boolean;
+    size?: Size;
+    fadeSize?: Size;
+    smooth?: boolean;
+    autoHide?: boolean;
+    offset?: Offset;
+    onScroll?: (e: React.UIEvent<HTMLDivElement>) => void;
+    children: ReactNode;
+};
+export {};

package/dist/esm/types/src/components/Select/Select.d.ts

@@ -0,0 +1,94 @@
+import { Component, ReactNode } from 'react';
+import { Input } from 'uilib/components/Input/Input';
+import * as T from './Select.types';
+import * as H from './Select.helpers';
+export declare const SelectHelpers: typeof H;
+export declare class Select extends Component<T.Props, T.State> {
+    store: any;
+    inputRef: import("react").RefObject<Input>;
+    triggerInputRef: import("react").RefObject<HTMLDivElement>;
+    contentRef: import("react").RefObject<HTMLDivElement>;
+    scrollInnerElem: HTMLDivElement;
+    onScrollInnerRef: (elem: any) => any;
+    focusedElem: HTMLDivElement;
+    timers: any;
+    items: any[];
+    maxIndex: number;
+    isFirstSelectedMeet: boolean;
+    isTree: boolean;
+    focusedItemId: string;
+    preventClose: boolean;
+    searchValLower: string;
+    optionsTree: T.Option[];
+    ids: {
+        items: {};
+        childIds: {};
+    };
+    static defaultProps: {
+        size: string;
+        additionalOptions: any[];
+    };
+    constructor(props: any);
+    componentDidUpdate(prevProps: any): void;
+    componentWillUnmount(): void;
+    onOptionsChange(): void;
+    coerceType(id: any): any;
+    getDefaultExpanded(value: any): {};
+    getDefaultSelected(): any;
+    isDisabled(): boolean;
+    isClickedInside: (elem: any) => any;
+    onFocusedElemRef: (elem: any) => void;
+    onDocumentClick: (e: any) => void;
+    onDocumentKeyDown: (e: any) => void;
+    onDocumentKeyUp: (e: any) => void;
+    unDocumetnKeyDown: () => void;
+    unDocumentClick: () => void;
+    onFocus: (e: any) => void;
+    onBlur: (e: any) => void;
+    onSearchChange: (e: any, value: any) => void;
+    onExpandClick(e: any, id: any): void;
+    onItemToggle(id: any): void;
+    onChange(selected: any): void;
+    onLabelClipPathChange: (clipPath: any) => any;
+    onPopupOpen: () => void;
+    onPopupClose: () => void;
+    onOptionHover: any;
+    setItemFocus: (index: any) => void;
+    toggle: () => void;
+    setSearchVal(searchVal: any): void;
+    getItems: () => T.Option[];
+    getParentId: (id: any) => any;
+    getChildIds: (id: any) => any;
+    isMultiple: () => boolean;
+    isErrorVisible: () => boolean;
+    isSelected(id: any): boolean | 'indeterminate';
+    addSelected(id: any, selected: any): any;
+    addSelectedToParent(id: any, selected: any): void;
+    removeSelected(id: any, selected: any): any;
+    removeSelectedChilds(id: any, selected: any): void;
+    removeSelectedFromParent(id: any, selected: any): void;
+    selectAll: () => void;
+    setSelected(ids: T.Id[]): void;
+    dropSelected: () => void;
+    getNewSelected(id: any): T.State['selected'];
+    getValue(): any;
+    getInputVal(): T.Value;
+    getLabel(id: any): any;
+    getFieldLabel(label: any): any;
+    getSelectedLabel(): string;
+    filterOption({ label }: {
+        label: any;
+    }): any;
+    getTriggerProps(): any;
+    renderAdditionalLabel(): JSX.Element;
+    renderTriggerInput(): JSX.Element;
+    renderTriggerButton(): JSX.Element;
+    renderTriggerArrow(): JSX.Element;
+    renderTrigger(): string | number | true | import("react").ReactFragment | JSX.Element;
+    renderFoldButton(id: any): JSX.Element;
+    renderOption: (item: any, level?: number) => JSX.Element[];
+    renderOptions(): ReactNode[];
+    renderPresets(): JSX.Element;
+    renderOptionsList(): JSX.Element;
+    render(): JSX.Element;
+}

package/dist/esm/types/src/components/Select/Select.helpers.d.ts

@@ -0,0 +1,14 @@
+import type { Option } from './Select.types';
+export declare function isMultiple(value: any): boolean;
+export declare function renderLabel({ label, render }: Option): string;
+export declare function buildOptionsTree(options: Option[], idsMap: IdsMap): Option[];
+type IdsMap = {
+    items: {
+        [key: string]: Option;
+    };
+    childIds: {
+        [key: string]: Option['id'][];
+    };
+};
+export declare function mapById(options: any): IdsMap;
+export {};

package/dist/esm/types/src/components/Select/Select.types.d.ts

@@ -0,0 +1,74 @@
+import { RefObject, ReactNode, HTMLAttributes } from 'react';
+import type { FormControl, Size } from 'uilib/types';
+import { InputProps } from '../Input/Input';
+import { PopupProps } from '../Popup/Popup';
+export type Id = string | number;
+export type Option = {
+    id: Id;
+    isGroupHeader?: boolean;
+    parentId?: Id;
+    label: any;
+    sortingKey?: string | number;
+    children?: Option[];
+    render?: (label: string) => string;
+};
+type Preset = {
+    label: string;
+    ids: Id[];
+};
+export type PresetButtonProps = {
+    key: string;
+    children: ReactNode;
+    onClick: () => void;
+};
+type SelectPopupProps = Omit<PopupProps, 'disabled' | 'direction' | 'autoClose' | 'onOpen' | 'onClose' | 'trigger' | 'content'> & Partial<{
+    direction: PopupProps['direction'];
+}>;
+type Selected = Record<string, true | Id[]>;
+export type Value = Id | Id[] | null;
+type InheritedInputProps = Partial<Pick<InputProps, 'onFocus' | 'onBlur'>>;
+export type Props = FormControl<Value> & InheritedInputProps & {
+    className?: string;
+    isOpen?: boolean;
+    optionsClassName?: string;
+    optionClassName?: string;
+    additionalLabel?: ReactNode;
+    size?: Size;
+    variant?: 'default' | 'outlined';
+    blur?: boolean;
+    options: Option[];
+    additionalOptions?: Option[];
+    presets?: Preset[];
+    clearButton?: boolean;
+    selectAllButton?: boolean;
+    value?: Value;
+    expandSelected?: boolean;
+    onChange: (value: Value) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    isSearchable?: boolean;
+    inputProps?: Omit<InputProps, 'value' | 'onChange' | 'onFocus' | 'onBlur' | 'size'>;
+    trigger?: ReactNode;
+    triggerProps?: any;
+    popupProps?: SelectPopupProps;
+    hideRequiredStar?: boolean;
+};
+export type State = {
+    isFocused: boolean;
+    isOpen: boolean;
+    isSelectionLimited: boolean;
+    selected: Selected;
+    expanded: {
+        [id: string]: boolean;
+    };
+    searchVal: string;
+    options: Option[];
+    labelClipPath: string;
+    optionsTreeUpd: number;
+};
+export type OptionElemProps = HTMLAttributes<HTMLDivElement> & {
+    className: string;
+    key: Option['id'];
+    ref?: RefObject<HTMLDivElement>;
+};
+export {};

package/dist/esm/types/src/components/Spinner/Spinner.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import * as T from './Spinner.types';
+export declare const Spinner: ({ size, className, ...props }: T.Props) => JSX.Element;

package/dist/esm/types/src/components/Spinner/Spinner.types.d.ts

@@ -0,0 +1,4 @@
+import { ComponentType, Size } from 'uilib/types';
+export type Props = ComponentType & {
+    size?: Size;
+};

package/dist/esm/types/src/components/Table/Table.d.ts

@@ -0,0 +1,8 @@
+import { Component } from 'react';
+import * as T from './Table.types';
+export declare class Table extends Component<T.Props> {
+    renderHeaderColumn: ({ id, label, sticky }: T.Column) => JSX.Element;
+    renderRow: (data: any) => JSX.Element;
+    renderDataCol({ id, dataField, render, sticky }: T.Column, data: T.Data): JSX.Element;
+    render(): JSX.Element;
+}

package/dist/esm/types/src/components/Table/Table.types.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { ComponentType } from 'uilib/types';
+export type Column = {
+    id: string;
+    label: ReactNode;
+    sticky?: boolean;
+    dataField?: string;
+    render?: (itemData: Data) => ReactNode;
+};
+export type Data = {
+    id: string;
+} & any;
+export type Props = ComponentType & {
+    columns: Column[];
+    data: Data[];
+    isLoading?: boolean;
+    loadingText?: ReactNode;
+    blur?: boolean;
+};

package/dist/esm/types/src/components/Tabs/Tabs.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import * as T from './Tabs.types';
+export declare function Tabs(props: T.Props): string | number | boolean | import("react").ReactFragment | JSX.Element;

package/dist/esm/types/src/components/Tabs/Tabs.types.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+import { Size } from 'uilib/types';
+import { ButtonProps } from '../Button/Button';
+type ID = string | number;
+export type Item = ButtonProps & {
+    id: ID;
+    label: string;
+    content: React.ReactNode | (() => React.ReactNode);
+    contentClassName?: string;
+    forceRender?: boolean;
+    onClick?: (e: MouseEvent) => boolean | void;
+};
+export type RenderProps = {
+    tabs: React.ReactNode;
+    content: React.ReactNode;
+};
+export type Props = {
+    size?: Size;
+    className?: string;
+    contentClassName?: string;
+    items: Item[];
+    activeId?: ID;
+    onChange: (id: ID) => void;
+    renderAll?: boolean;
+    children?: (props: RenderProps) => React.ReactNode;
+};
+export {};

package/dist/esm/types/src/components/Text/Text.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const H1: (props: any) => JSX.Element;
+export declare const H2: (props: any) => JSX.Element;
+export declare const H3: (props: any) => JSX.Element;
+export declare const H4: (props: any) => JSX.Element;
+export declare const H5: (props: any) => JSX.Element;
+export declare const H6: (props: any) => JSX.Element;

package/dist/esm/types/src/components/Theme/Theme.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import * as T from './Theme.types';
+export declare function Theme({ config }: T.Props): JSX.Element;
+export * as ThemeHelpers from './Theme.helpers';
+export * as ThemeDefaults from './Theme.defaults';

package/dist/esm/types/src/components/Theme/Theme.defaults.d.ts

@@ -0,0 +1,32 @@
+import * as T from './Theme.types';
+export declare const baseConfig: {
+    'indent-s': string;
+    'indent-m': string;
+    'indent-l': string;
+    'border-radius-s': string;
+    'border-radius-m': string;
+    'border-radius-l': string;
+};
+export declare const colors: {
+    light: string;
+    dark: string;
+};
+type ColorConfig = {
+    [key: string]: string | {
+        color: string;
+        mods: {
+            alpha: number[];
+        };
+    };
+};
+export declare function getColors({ accent, decent, active, warning, danger, disabled, link, }?: {
+    accent?: string;
+    decent?: string;
+    active?: string;
+    warning?: string;
+    danger?: string;
+    disabled?: string;
+    link?: string;
+}): ColorConfig;
+export declare const getConfig: (cfg?: T.ThemeConfig) => any;
+export {};

package/dist/esm/types/src/components/Theme/Theme.helpers.d.ts

@@ -0,0 +1,15 @@
+export declare function mixColor(color1: string, color2: string, val?: number): string;
+export declare function rgba(color: string, transparency: number): string;
+export declare function getRGB(color: string): string;
+type ColorMods = {
+    [name: string]: number[];
+};
+type ColorConfig = string | {
+    color: string;
+    mods: ColorMods;
+};
+type ColorsConfig = {
+    [name: string]: ColorConfig;
+};
+export declare function colorsConfigToVars(config: ColorsConfig): {};
+export {};

package/dist/esm/types/src/components/Theme/Theme.types.d.ts

@@ -0,0 +1,6 @@
+export type ThemeConfig = Record<string, string> & {
+    colors?: Record<string, string>;
+};
+export type Props = {
+    config?: ThemeConfig;
+};

package/dist/esm/types/src/components/VH/VH.d.ts

@@ -0,0 +1,12 @@
+import { Component } from 'react';
+type State = {
+    vh: number;
+};
+export declare class VH extends Component<any, State> {
+    constructor(props: any);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    updateVH: () => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/esm/types/src/components/Virtualized/Cards/Cards.d.ts

@@ -0,0 +1,26 @@
+import { Component } from 'react';
+import List from '../List/List';
+import * as T from '../Virtualized.types';
+type Props = T.Props & {
+    itemMinWidth: number;
+    itemMaxWidth: number;
+    itemsMinMargin: number;
+};
+declare class ListCards extends Component<Props> {
+    listElem: import("react").RefObject<List>;
+    state: {
+        itemsInRow: number;
+        itemsCount: number;
+        totalCount: number;
+        overlapCount: number;
+    };
+    static defaultProps: {
+        itemsMinMargin: number;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: any): void;
+    updateUnits: () => void;
+    renderItem: ({ className, key, style }: T.ItemProps) => JSX.Element;
+    render(): JSX.Element[];
+}
+export default ListCards;