onekijs-ui 0.9.2 → 0.15.2

package/dist/components/table/components/TableBodyRowComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TableBodyRowProps } from '../typings';
+declare const TableBodyRowComponent: FC<TableBodyRowProps>;
+export default TableBodyRowComponent;

package/dist/components/table/components/TableComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableProps } from '../typings';
+declare const TableComponent: React.FC<TableProps>;
+export default TableComponent;

package/dist/components/table/components/TableFooterCellComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TableFooterCellProps } from '../typings';
+declare const TableFooterCellComponent: FC<TableFooterCellProps>;
+export default TableFooterCellComponent;

package/dist/components/table/components/TableFooterComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableFooterProps } from '../typings';
+declare const TableFooterComponent: React.FC<TableFooterProps>;
+export default TableFooterComponent;

package/dist/components/table/components/TableHeaderComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableHeaderProps } from '../typings';
+declare const TableHeaderComponent: React.FC<TableHeaderProps>;
+export default TableHeaderComponent;

package/dist/components/table/components/TableHeaderFilterComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TableHeaderCellProps } from '../typings';
+declare const TableHeaderFilterComponent: FC<TableHeaderCellProps>;
+export default TableHeaderFilterComponent;

package/dist/components/table/components/TableHeaderTitleComponent.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { TableHeaderCellProps } from '../typings';
+export declare const DefaultTableHeaderTitleComponent: FC<TableHeaderCellProps>;
+declare const TableHeaderTitleComponent: FC<TableHeaderCellProps>;
+export default TableHeaderTitleComponent;

package/dist/components/table/components/TableLoadingComponent.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: import("styled-components").StyledComponent<React.FC<React.InputHTMLAttributes<HTMLDivElement>>, any, {}, never>;
+export default _default;

package/dist/components/table/components/TableLoadingRowComponent.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: import("styled-components").StyledComponent<React.FC<React.InputHTMLAttributes<HTMLDivElement>>, any, {}, never>;
+export default _default;

package/dist/components/table/components/TableNotFoundComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableNotFoundProps } from '../typings';
+declare const TableNotFoundComponent: React.FC<TableNotFoundProps>;
+export default TableNotFoundComponent;

package/dist/components/table/components/TableSortComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TableSortProps } from '../typings';
+declare const TableSortComponent: FC<TableSortProps>;
+export default TableSortComponent;

package/dist/components/table/components/cells/CheckboxCellComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableBodyCellProps, UseCheckboxColumnOptions } from '../../typings';
+declare const CheckboxCellComponent: (options: UseCheckboxColumnOptions<any, any>) => React.FC<TableBodyCellProps<any, any>>;
+export default CheckboxCellComponent;

package/dist/components/table/components/cells/DefaultCellComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TableBodyCellProps } from '../../typings';
+declare const DefaultCellComponent: FC<TableBodyCellProps>;
+export default DefaultCellComponent;

package/dist/components/table/components/cells/ExpandedCellComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TableBodyCellProps } from '../../typings';
+declare const ExpandedCellComponent: FC<TableBodyCellProps>;
+export default ExpandedCellComponent;

package/dist/components/table/components/cells/InputCellComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableBodyCellProps, UseInputColumnOptions } from '../../typings';
+declare const InputCellComponent: (options: UseInputColumnOptions<any, any>) => React.FC<TableBodyCellProps<any, any>>;
+export default InputCellComponent;

package/dist/components/table/components/cells/SelectCellComponent.d.ts

@@ -0,0 +1,6 @@
+import { CollectionBroker } from 'onekijs-framework';
+import React from 'react';
+import { SelectItem } from '../../../select/typings';
+import { TableBodyCellProps, UseSelectColumnOptions } from '../../typings';
+declare const SelectCellComponent: (options: UseSelectColumnOptions<any, SelectItem<any>>, broker: CollectionBroker<any, SelectItem<any>>) => React.FC<TableBodyCellProps>;
+export default SelectCellComponent;

package/dist/components/table/components/filters/TableInputFilterComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableHeaderCellProps } from '../../typings';
+declare const TableInputFilterComponent: React.FC<TableHeaderCellProps>;
+export default TableInputFilterComponent;

package/dist/components/table/components/hoc/linkCellComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TableBodyCellProps } from '../../typings';
+declare const linkCellComponent: (href: string | ((item: any) => string)) => FC<TableBodyCellProps>;
+export default linkCellComponent;

package/dist/components/table/hooks/useFormTableContext.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { FormTableContext } from '../typings';
+export declare const DefaultFormTableContext: React.Context<FormTableContext<any>>;
+declare const useFormTableContext: () => FormTableContext;
+export default useFormTableContext;

package/dist/components/table/hooks/useTableColumns.d.ts

@@ -0,0 +1,3 @@
+import { TableColumn, TableItem } from '../typings';
+declare const useTableColumns: <T = any, I extends TableItem<T> = TableItem<T>>() => TableColumn<T, I>[];
+export default useTableColumns;

package/dist/components/table/hooks/useTableConfig.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableConfig, TableItem } from '../typings';
+export declare const TableConfigContext: React.Context<TableConfig<any, any>>;
+export declare const useTableConfig: <T = any, I extends TableItem<T> = TableItem<T>>() => TableConfig<T, I>;

package/dist/components/table/hooks/useTableController.d.ts

@@ -0,0 +1,5 @@
+import { CollectionProxy } from 'onekijs-framework';
+import TableService from '../TableService';
+import { TableColumn, TableItem, TableState, UseTableOptions } from '../typings';
+declare const useTableController: <T>(dataSource: string | T[] | undefined, initialColumns: TableColumn<T, TableItem<T>>[] | undefined, options?: UseTableOptions<T, TableItem<T>>) => CollectionProxy<T, TableItem<T>, TableState<T, TableItem<T>>, TableService<T, TableItem<T>, TableState<T, TableItem<T>>>>;
+export default useTableController;

package/dist/components/table/hooks/useTableInitialState.d.ts

@@ -0,0 +1,3 @@
+import { TableColumn, TableItem, TableState, UseTableOptions } from '../typings';
+declare const useTableInitialState: <T, I extends TableItem<T>>(dataSource: string | T[] | undefined, initialColumns: TableColumn<T, I>[] | undefined, options: UseTableOptions<T, I>) => TableState<T, I>;
+export default useTableInitialState;

package/dist/components/table/hooks/useTableItems.d.ts

@@ -0,0 +1,3 @@
+import { TableItem } from '../typings';
+declare const useTableItems: <T = any, I extends TableItem<T> = TableItem<T>>() => (I | undefined)[];
+export default useTableItems;

package/dist/components/table/hooks/useTableService.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { TableController, TableItem } from '../typings';
+export declare const TableServiceContext: React.Context<TableController<any, any, import("../typings").TableState<any, any>>>;
+declare const useTableService: <T = any, I extends TableItem<T> = TableItem<T>>() => TableController<T, I, import("../typings").TableState<T, I>>;
+export default useTableService;

package/dist/components/table/hooks/useTableState.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableItem, TableState } from '../typings';
+export declare const TableStateContext: React.Context<TableState<any, any>>;
+export declare const useTableState: <T = any, I extends TableItem<T> = TableItem<T>>() => TableState<T, I>;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const Table: import("styled-components").StyledComponent<import("react").FC<import("./typings").TableProps<any, import("./typings").TableItem<any>, import("./typings").TableState<any, import("./typings").TableItem<any>>, import("./typings").TableController<any, import("./typings").TableItem<any>, import("./typings").TableState<any, import("./typings").TableItem<any>>>>>, any, {}, never>;
+export default Table;

package/dist/components/table/style.d.ts

@@ -0,0 +1,3 @@
+import { ComponentStyle } from '../../styles/typings';
+import { TableProps } from './typings';
+export declare const tableStyle: ComponentStyle<TableProps<any>>;

package/dist/components/table/typings.d.ts

@@ -0,0 +1,218 @@
+import { Collection, CollectionBroker, CollectionBy, CollectionProxy, FormFieldProps, Item, ItemAdaptee, QueryFilterOrCriteria, QuerySortBy, UseCollectionOptions, ValidationStatus } from 'onekijs-framework';
+import React, { FC } from 'react';
+import { TshirtSize } from '../../styles/typings';
+import { CheckboxProps } from '../checkbox/typings';
+import { FieldLayoutProps } from '../field/typings';
+import { InputProps } from '../input/typings';
+import { ListItemProps, ListItems, ListNotFoundProps, ListState, UseListOptions } from '../list/typings';
+import { SelectItem, SelectProps } from '../select/typings';
+export declare type ArrayTableProps<T = any, I extends TableItem<T> = TableItem<T>> = TableConfig<T, I> & {
+    adapter?: TableItemAdapter<T>;
+    columns?: TableColumn<T, I>[];
+    dataSource?: string | T[];
+    fetchOnce?: boolean;
+    selected?: T[];
+};
+export declare type ControllerTableProps<T = any, I extends TableItem<T> = TableItem<T>, S extends TableState<T, I> = TableState<T, I>, C extends TableController<T, I, S> = TableController<T, I, S>> = TableConfig<T, I> & {
+    controller: CollectionProxy<T, I, S, C>;
+};
+export declare type FormTableProps<T = any, I extends TableItem<T> = TableItem<T>, S extends TableState<T, I> = TableState<T, I>, C extends TableController<T, I, S> = TableController<T, I, S>> = ControllerTableProps<T, I, S, C> & FormFieldProps & FieldLayoutProps & {
+    addLabel?: string;
+    format?: 'id' | 'object' | 'auto';
+    defaultValue?: T[];
+    FieldComponent?: React.FC<FormTableProps<T, I, S, C>>;
+    value?: T[];
+    onFocus?: () => void;
+    onBlur?: () => void;
+    onChange?: (value: T[]) => void;
+    status?: ValidationStatus;
+    size?: TshirtSize;
+};
+export declare type FormTableContext<T = any> = {
+    tableName: string;
+    onSelect: (item: TableItem<T>, selected: boolean) => void;
+    addLabel: string;
+    required?: boolean;
+    maxLength?: number;
+    minLength?: number;
+};
+export declare type TableBodyCellProps<T = any, I extends TableItem<T> = TableItem<T>> = {
+    className?: string;
+    colIndex: number;
+    column: TableColumn<T, I>;
+    rowId?: string | number;
+    rowIndex: number;
+    item: I;
+    data: T;
+};
+export declare type Cell<T = any, I extends TableItem<T> = TableItem<T>> = FC<TableBodyCellProps<T, I>>;
+export declare type TableBodyProps<T = any, I extends TableItem<T> = TableItem<T>> = {
+    className?: string;
+    columns: TableColumn<T, I>[];
+    items: (I | undefined)[];
+    contentRef: React.RefObject<HTMLDivElement>;
+    tableRef: React.RefObject<HTMLDivElement>;
+};
+export declare type TableBodyRowProps<T = any, I extends TableItem<T> = TableItem<T>> = Omit<ListItemProps<T, I>, 'CellComponent'> & {
+    className?: string;
+    CellComponent?: React.FC<Omit<TableBodyCellProps<T, I>, 'data'>>;
+    columns: TableColumn<T, I>[];
+    onExpand?: (item: I | undefined, index: number) => void;
+    onExpanding?: (item: I | undefined, index: number) => void;
+    onExpanded?: (item: I | undefined, index: number) => void;
+    onCollapse?: (item: I | undefined, index: number) => void;
+    onCollapsing?: (item: I | undefined, index: number) => void;
+    onCollapsed?: (item: I | undefined, index: number) => void;
+};
+export declare type TableConfig<T = any, I extends TableItem<T> = TableItem<T>> = {
+    bodyClassName?: string;
+    BodyComponent?: React.FC<TableBodyProps<T, I>>;
+    className?: string;
+    ExpandedComponent?: React.FC<TableExpandedProps<T, I>>;
+    filterable?: boolean;
+    fit?: boolean;
+    fixHeader?: boolean;
+    footer?: boolean;
+    footerClassName?: string;
+    FooterComponent?: React.FC<TableFooterProps<T, I>>;
+    grow?: string;
+    header?: boolean;
+    headerClassName?: string;
+    HeaderComponent?: React.FC<TableHeaderProps<T, I>>;
+    height?: string;
+    highlightRow?: boolean;
+    increment?: number;
+    LoadingComponent?: React.FC;
+    LoadingRowComponent?: React.FC;
+    NotFoundComponent?: React.FC<TableNotFoundProps> | null;
+    onRowClick?: TableRowHandler<T, I>;
+    onRowEnter?: TableRowHandler<T, I>;
+    onRowLeave?: TableRowHandler<T, I>;
+    onRowOver?: TableRowHandler<T, I>;
+    onRowOut?: TableRowHandler<T, I>;
+    preload?: number;
+    rowClassName?: string | ((item: I | undefined, rowIndex: number, columns: TableColumn<T, I>[]) => string);
+    RowComponent?: React.FC<TableBodyRowProps<T, I>>;
+    sortable?: boolean;
+    stripRows?: boolean;
+};
+export declare type TableController<T = any, I extends TableItem<T> = TableItem<T>, S extends TableState<T, I> = TableState<T, I>> = Collection<T, I, S> & {
+    addColumn(column: TableColumn<T, I>, position?: number): void;
+    addSelected<B extends keyof CollectionBy<T, I>>(by: B, target: CollectionBy<T, I>[B] | CollectionBy<T, I>[B][]): I[];
+    columns: TableColumn<T, I>[];
+    initCell(rowIndex: number | 'header-title' | 'header-filter' | 'footer', colId: string, ref: React.RefObject<HTMLDivElement>): void;
+    removeColumn(id: string): void;
+    removeSelected<B extends keyof CollectionBy<T, I>>(by: B, target: CollectionBy<T, I>[B] | CollectionBy<T, I>[B][]): I[];
+    setSelected<B extends keyof CollectionBy<T, I>>(by: B, target: CollectionBy<T, I>[B] | CollectionBy<T, I>[B][]): I[];
+    toggle(item: I): void;
+};
+export declare type TableColumn<T, I extends TableItem<T> = TableItem<T>> = TableColumnSpec<T, I> & {
+    computedWidth?: TableColumnComputedWidth;
+};
+export declare type TableColumnSpec<T, I extends TableItem<T> = TableItem<T>> = {
+    className?: string | ((item: I, column: TableColumn<T, I>, rowIndex: number) => string);
+    CellComponent?: Cell<T, I>;
+    footerClassName?: string | ((column: TableColumn<T, I>) => string);
+    FooterComponent?: React.FC<TableFooterCellProps<T, I>>;
+    filterable?: boolean;
+    FilterComponent?: React.FC<TableHeaderCellProps<T, I>>;
+    headerClassName?: string | ((column: TableColumn<T, I>) => string);
+    id: string;
+    maxWidth?: string;
+    minWidth?: string;
+    sortable?: boolean;
+    title?: string;
+    TitleComponent?: React.FC<TableHeaderCellProps<T, I>>;
+    weight?: number;
+    width?: string;
+};
+export declare type TableColumnWidth = {
+    auto?: boolean;
+    grow?: boolean;
+    force?: boolean;
+    unit?: 'px' | '%';
+    value?: number;
+};
+export declare type TableColumnComputedWidth = {
+    width?: string;
+    minWidth?: string;
+};
+export declare type TableExpandedProps<T = any, I extends TableItem<T> = TableItem<T>> = {
+    item: I;
+    rowId?: string | number;
+    rowIndex: number;
+};
+export declare type TableFooterCellProps<T = any, I extends TableItem<T> = TableItem<T>> = {
+    className?: string;
+    colIndex: number;
+    column: TableColumn<T, I>;
+};
+export declare type TableFooterProps<T = any, I extends TableItem<T> = TableItem<T>> = {
+    className?: string;
+    columns: TableColumn<T, I>[];
+};
+export declare type TableHeaderCellProps<T = any, I extends TableItem<T> = TableItem<T>> = {
+    className?: string;
+    colIndex: number;
+    column: TableColumn<T, I>;
+    filter?: QueryFilterOrCriteria;
+    filterable: boolean;
+    sort?: QuerySortBy;
+    sortable: boolean;
+};
+export declare type TableHeaderProps<T = any, I extends TableItem<T> = TableItem<T>> = {
+    className?: string;
+    columns: TableColumn<T, I>[];
+};
+export declare type TableItem<T = any> = Item<T> & {
+    expanded?: boolean;
+};
+export declare type TableItemAdaptee = ItemAdaptee;
+export declare type TableItemAdapter<T = any> = (data: T) => TableItemAdaptee;
+export declare type TableRowHandler<T = any, I extends TableItem<T> = TableItem<T>> = (item: I, index: number) => void;
+export declare type TableItems<T = any> = ListItems<T>;
+export declare type TableNotFoundProps = ListNotFoundProps;
+export declare type TableProps<T = any, I extends TableItem<T> = TableItem<T>, S extends TableState<T, I> = TableState<T, I>, C extends TableController<T, I, S> = TableController<T, I, S>> = TableConfig<T, I> & {
+    adapter?: TableItemAdapter<T>;
+    controller?: CollectionProxy<T, I, S, C>;
+    columns?: TableColumn<T, I>[];
+    dataSource?: string | T[];
+    fetchOnce?: boolean;
+    selected?: T[];
+};
+export declare type TableSortProps<T = any, I extends TableItem<T> = TableItem<T>> = {
+    column: TableColumn<T, I>;
+    sort?: QuerySortBy;
+};
+export declare type TableState<T = any, I extends TableItem<T> = TableItem<T>> = ListState<T, I> & {
+    adapter?: TableItemAdapter<T>;
+    columns: TableColumn<T, I>[];
+    dataSource?: T[] | string;
+    selected?: string[];
+};
+export declare type TableColumnsState<T = any, I extends TableItem<T> = TableItem<T>> = {
+    columns: TableColumn<T, I>[];
+};
+export declare type CheckboxColumn<T = any, I extends TableItem<T> = TableItem<T>> = TableColumn<T, I>;
+export declare type InputColumn<T = any, I extends TableItem<T> = TableItem<T>> = TableColumn<T, I>;
+export declare type SelectColumn<T = any, I extends TableItem<T> = TableItem<T>> = TableColumn<T, I> & {
+    broker: CollectionBroker<T, I>;
+};
+export declare type UseLinkColumnOptions<T = any, I extends TableItem<T> = TableItem<T>> = Omit<TableColumnSpec<T, I>, 'CellComponent'> & {
+    href: string | ((item: I) => string);
+};
+export declare type UseCheckboxColumnOptions<T = any, I extends TableItem<T> = TableItem<T>> = Omit<TableColumnSpec<T, I>, 'CellComponent'> & Omit<FormFieldProps, 'name'> & Omit<CheckboxProps, 'className' | 'onFocus' | 'onChange' | 'onBlur' | 'defaultValue'> & {
+    CellComponent?: (options: UseCheckboxColumnOptions<T, I>) => React.FC<TableBodyCellProps<T, I>>;
+    defaultValue?: boolean;
+};
+export declare type UseInputColumnOptions<T = any, I extends TableItem<T> = TableItem<T>> = Omit<TableColumnSpec<T, I>, 'CellComponent'> & Omit<FormFieldProps, 'name'> & Omit<InputProps, 'className' | 'onFocus' | 'onChange' | 'onBlur'> & {
+    CellComponent?: (options: UseInputColumnOptions<T, I>) => React.FC<TableBodyCellProps<T, I>>;
+};
+export declare type UseSelectColumnOptions<T = any, I extends TableItem<T> = TableItem<T>, F = any, FI extends SelectItem<F> = SelectItem<F>> = Omit<TableColumnSpec<T, I>, 'CellComponent'> & Omit<SelectProps, 'className' | 'onFocus' | 'onChange' | 'onBlur' | 'items'> & Omit<FormFieldProps, 'name'> & UseCollectionOptions<F, FI> & {
+    dataSource: string | F[];
+    CellComponent?: (options: UseSelectColumnOptions<F, FI>, broker: CollectionBroker<F, FI>) => React.FC<TableBodyCellProps<T, I>>;
+};
+export declare type UseTableOptions<T = any, I extends TableItem<T> = TableItem<T>> = UseListOptions<T, I> & {
+    adapter?: TableItemAdapter<T>;
+    selected?: T[];
+};

package/dist/components/table/util.d.ts

@@ -0,0 +1,5 @@
+import { QueryFilterOrCriteria } from 'onekijs-framework';
+import { CSSProperties } from 'react';
+import { TableColumn, TableItem } from './typings';
+export declare const getCellWidth: (column: TableColumn<any, TableItem<any>>, fit?: boolean, grow?: string) => CSSProperties;
+export declare const getValueFromFilter: (filter?: QueryFilterOrCriteria) => string;

package/dist/components/tag/components/TagComponent.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { TagProps } from '../typings';
+declare const TagComponent: FCC<TagProps>;
+export default TagComponent;

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

@@ -0,0 +1,2 @@
+declare const Tag: import("styled-components").StyledComponent<import("onekijs-framework").FCC<import("./typings").TagProps>, any, {}, never>;
+export default Tag;

package/dist/components/tag/style.d.ts

@@ -0,0 +1,3 @@
+import { ComponentStyle } from '../../styles/typings';
+import { TagProps } from './typings';
+export declare const tagStyle: ComponentStyle<TagProps>;

package/dist/components/tag/typings.d.ts

@@ -0,0 +1,16 @@
+import { BackgroundColorProperty, ColorProperty, MarginProperty } from 'csstype';
+import { ReactNode } from 'react';
+import { ColorPropertyTheme, SpacingPropertyTheme, TLength } from '../../styles/typings';
+export declare type TagProps = {
+    kind?: ColorPropertyTheme;
+    bgColor?: ColorPropertyTheme | BackgroundColorProperty;
+    fontColor?: ColorPropertyTheme | ColorProperty;
+    size?: 'small' | 'medium' | 'large';
+    onClick?: (event: React.MouseEvent<HTMLElement>) => void;
+    className?: string;
+    marginLeft?: SpacingPropertyTheme | MarginProperty<TLength>;
+    marginRight?: SpacingPropertyTheme | MarginProperty<TLength>;
+    marginTop?: SpacingPropertyTheme | MarginProperty<TLength>;
+    marginBottom?: SpacingPropertyTheme | MarginProperty<TLength>;
+    icon?: ReactNode;
+};

package/dist/components/tooltip/components/TooltipComponent.d.ts

@@ -0,0 +1,4 @@
+import { FCC } from 'onekijs-framework';
+import { TooltipProps } from '../typings';
+declare const TooltipComponent: FCC<TooltipProps>;
+export default TooltipComponent;

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

@@ -0,0 +1,2 @@
+declare const Tooltip: import("styled-components").StyledComponent<import("onekijs-framework").FCC<import("./typings").TooltipProps>, any, {}, never>;
+export default Tooltip;

package/dist/components/tooltip/style.d.ts

@@ -0,0 +1,4 @@
+import { ComponentStyle } from '../../styles/typings';
+import { TooltipProps } from './typings';
+declare const tooltipStyle: ComponentStyle<TooltipProps>;
+export default tooltipStyle;

package/dist/components/tooltip/typings.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Config, PopperOptions } from 'react-popper-tooltip';
+import { ColorPropertyTheme } from '../../styles/typings';
+export interface TooltipProps extends Config {
+    content?: string | JSX.Element;
+    className?: string;
+    popperOptions?: PopperOptions;
+    kind?: ColorPropertyTheme;
+    delayHide?: number;
+}

package/dist/components/tree/TreeService.d.ts

@@ -0,0 +1,23 @@
+import { AnonymousObject, CollectionFetcherResult, CollectionService, LocalQuery, QuerySortComparator } from 'onekijs-framework';
+import { Task } from 'redux-saga';
+import { TreeController, TreeItem, TreeState } from './typings';
+declare class TreeService<T = any, I extends TreeItem<T> = TreeItem<T>, S extends TreeState<T, I> = TreeState<T, I>> extends CollectionService<T, I, S> implements TreeController<T, I> {
+    adapt(data: T | undefined): I;
+    collapse(item: I): void;
+    collpased(item: I): void;
+    collapsing(item: I): void;
+    expand(item: I): Generator<void | Generator<void | I[] | import("redux-saga/effects").CancelEffect | import("redux-saga/effects").ForkEffect<Generator<I[] | import("redux-saga/effects").CallEffect<true>, void, unknown>> | Promise<CollectionFetcherResult<T>>, void, (Task<any> | null) & CollectionFetcherResult<T>>, void, unknown>;
+    expanded(item: I): void;
+    expanding(item: I): Generator<void | Generator<void | I[] | import("redux-saga/effects").CancelEffect | import("redux-saga/effects").ForkEffect<Generator<I[] | import("redux-saga/effects").CallEffect<true>, void, unknown>> | Promise<CollectionFetcherResult<T>>, void, (Task<any> | null) & CollectionFetcherResult<T>>, void, unknown>;
+    initDb(dataSource: T[] | string | undefined): void;
+    protected _adapt(data: T | undefined, context?: AnonymousObject): I;
+    protected _buildItem(data: T | undefined, adaptee: unknown, context?: AnonymousObject): I;
+    protected _delayChildrenLoading(delay_ms: number, item: I): Generator<I[] | import("redux-saga/effects").CallEffect<true>, void, unknown>;
+    protected _execute(items: I[], query: LocalQuery, comparator: QuerySortComparator, comparators: AnonymousObject<QuerySortComparator>): I[];
+    _expand(item: I): void;
+    _expanding(item: I): void;
+    protected _fetchChildren(item: I, callbackSuccess?: (item: I) => void, callbackError?: (item: I) => void): Generator<void | I[] | import("redux-saga/effects").CancelEffect | import("redux-saga/effects").ForkEffect<Generator<I[] | import("redux-saga/effects").CallEffect<true>, void, unknown>> | Promise<CollectionFetcherResult<T>>, void, (Task<any> | null) & CollectionFetcherResult<T>>;
+    protected _fetchChildrenError(e: any, item: I): void;
+    protected _fetchChildrenSuccess(item: I, result: CollectionFetcherResult<T>): void;
+}
+export default TreeService;

package/dist/components/tree/components/ArrayTreeComponent.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { ArrayTreeProps } from '../typings';
+declare const ArrayTreeComponent: FC<ArrayTreeProps>;
+export default ArrayTreeComponent;

package/dist/components/tree/components/ControllerTreeComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ControllerTreeProps } from '../typings';
+declare const ControllerTreeComponent: React.FC<ControllerTreeProps>;
+export default ControllerTreeComponent;

package/dist/components/tree/components/TreeBodyComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ControllerTreeProps } from '../typings';
+declare const TreeBodyComponent: React.FC<ControllerTreeProps>;
+export default TreeBodyComponent;

package/dist/components/tree/components/TreeComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TreeProps } from '../typings';
+declare const TreeComponent: React.FC<TreeProps>;
+export default TreeComponent;

package/dist/components/tree/components/TreeItemComponent.d.ts

@@ -0,0 +1,6 @@
+import React, { FC } from 'react';
+import { TreeItemProps, TreeItemToggleProps } from '../typings';
+export declare const TreeItemToggler: React.FC<TreeItemToggleProps>;
+export declare const TreeItemContent: React.FC<TreeItemProps>;
+declare const TreeItemComponent: FC<TreeItemProps>;
+export default TreeItemComponent;

package/dist/components/tree/components/TreeListComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TreeListProps } from '../typings';
+declare const TreeListComponent: React.FC<TreeListProps>;
+export default TreeListComponent;

package/dist/components/tree/components/VirtualTreeBodyComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ControllerTreeProps } from '../typings';
+declare const VirtualTreeBodyComponent: React.FC<ControllerTreeProps>;
+export default VirtualTreeBodyComponent;

package/dist/components/tree/components/VirtualTreeListComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { VirtualTreeListProps } from '../typings';
+declare const VirtualTreeListComponent: React.FC<VirtualTreeListProps>;
+export default VirtualTreeListComponent;

package/dist/components/tree/hooks/useTreeConfig.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TreeConfig, TreeItem } from '../typings';
+export declare const TreeConfigContext: React.Context<TreeConfig<any, any>>;
+export declare const useTreeConfig: <T = any, I extends TreeItem<T> = TreeItem<T>>() => TreeConfig<T, I>;

package/dist/components/tree/hooks/useTreeController.d.ts

@@ -0,0 +1,5 @@
+import { CollectionProxy } from 'onekijs-framework';
+import TreeService from '../TreeService';
+import { TreeItem, TreeState, UseTreeOptions } from '../typings';
+declare const useTreeController: <T>(dataSource?: string | T[] | CollectionProxy<T, TreeItem<T>, TreeState<T, TreeItem<T>>, TreeService<T, TreeItem<T>, TreeState<T, TreeItem<T>>>> | undefined, options?: UseTreeOptions<T, TreeItem<T>>) => CollectionProxy<T, TreeItem<T>, TreeState<T, TreeItem<T>>, TreeService<T, TreeItem<T>, TreeState<T, TreeItem<T>>>>;
+export default useTreeController;

package/dist/components/tree/hooks/useTreeInitialState.d.ts

@@ -0,0 +1,5 @@
+import { CollectionProxy } from 'onekijs-framework';
+import TreeService from '../TreeService';
+import { TreeItem, TreeState, UseTreeOptions } from '../typings';
+declare const useTreeInitialState: <T, I extends TreeItem<T>>(dataSource: string | T[] | CollectionProxy<T, I, TreeState<T, I>, TreeService<T, I, TreeState<T, I>>> | undefined, options: UseTreeOptions<T, I>) => TreeState<T, I>;
+export default useTreeInitialState;

package/dist/components/tree/hooks/useTreeItems.d.ts

@@ -0,0 +1,3 @@
+import { TreeItem } from '../typings';
+declare const useTreeItems: <T = any, I extends TreeItem<T> = TreeItem<T>>() => (I | undefined)[];
+export default useTreeItems;

package/dist/components/tree/hooks/useTreeService.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { TreeController, TreeItem } from '../typings';
+export declare const TreeServiceContext: React.Context<TreeController<any, any, import("../typings").TreeState<any, any>>>;
+declare const useTreeService: <T = any, I extends TreeItem<T> = TreeItem<T>>() => TreeController<T, I, import("../typings").TreeState<T, I>>;
+export default useTreeService;

package/dist/components/tree/hooks/useTreeState.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TreeItem, TreeState } from '../typings';
+export declare const TreeStateContext: React.Context<TreeState<any, any>>;
+export declare const useTreeState: <T = any, I extends TreeItem<T> = TreeItem<T>>() => TreeState<T, I>;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const Tree: import("styled-components").StyledComponent<import("react").FC<import("./typings").TreeProps<any, import("./typings").TreeItem<any>, import("./typings").TreeState<any, import("./typings").TreeItem<any>>, import("./typings").TreeController<any, import("./typings").TreeItem<any>, import("./typings").TreeState<any, import("./typings").TreeItem<any>>>>>, any, {}, never>;
+export default Tree;

package/dist/components/tree/style.d.ts

@@ -0,0 +1,3 @@
+import { ComponentStyle } from '../../styles/typings';
+import { TreeProps } from './typings';
+export declare const treeStyle: ComponentStyle<TreeProps<any>>;