@zeedhi/common 1.111.1 → 3.0.0

package/dist/types/components/zd-iterable/column-not-found.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Column not found error
+ */
+export declare class ColumnNotFoundError extends Error {
+    constructor(name: string, parentName: string);
+}

package/dist/types/components/zd-iterable/column.d.ts

@@ -0,0 +1,78 @@
+import { Datasource, IDictionary } from '@zeedhi/core';
+import { Component } from '../zd-component/component';
+import { ColumnAlign, ColumnType, IColumn } from './interfaces';
+/**
+ * Base class for Column.
+ */
+export declare class Column extends Component implements IColumn {
+    align: ColumnAlign;
+    label: string;
+    width?: string;
+    maxWidth?: string;
+    minWidth?: string;
+    mask: string;
+    type?: ColumnType;
+    actionFixed: boolean;
+    fixed: boolean;
+    sortable: boolean;
+    loading: boolean;
+    componentProps: any;
+    /** column style property */
+    style: IDictionary;
+    /** Type of XLS */
+    xlsType: string;
+    protected lookupDatasource?: Datasource;
+    lookupData: any;
+    lookupDataCount: number;
+    protected dataToLookup?: any[];
+    /**
+     * Column overflow behaviour when column has max width
+     * 'ellipsis' - show ellipsis (...) at end
+     * 'hidden' - just crop value
+     * 'wrap' - show value using multiple lines
+     * <2..5> - show value using multiple lines with <number> max lines (line-clamp)
+     */
+    overflow: string | number;
+    conditions: IDictionary;
+    /**
+     * Method to get the current column width, assigned by view layer.
+     */
+    private viewGetWidth?;
+    helperText: string;
+    protected defaultData: IDictionary[];
+    private lookup;
+    /**
+     * Defines if the column should store the componentProps datasource.data in memory
+     */
+    storeData: boolean;
+    /**
+     * Creates a new Column.
+     * @param props Column properties
+     */
+    constructor(props: IColumn);
+    /**
+     * Sets view getWidth method.
+     */
+    setViewGetWidth(viewGetWidth: () => number): void;
+    /**
+     * * Sets a filter to lookupData.
+     */
+    setLookupDataFilter(filter: IDictionary): void;
+    /**
+     * Gets the column width.
+     */
+    getWidth(): number;
+    formatterByRow(row: IDictionary<any>, cellProps?: IDictionary): any;
+    formatter(value: any, cellProps?: IDictionary): any;
+    getLookupData(lookupColumn: string, value: any): any;
+    /**
+     * Initialize the lookup property, properly setting the debounced function
+     */
+    initialize(): void;
+    protected lookupFn(lookupColumn: string, dataToLookup?: any[]): Promise<void>;
+    /**
+     * Clear lookupData to force new requests
+     */
+    clearLookupData(): void;
+    onBeforeDestroy(): void;
+}

package/dist/types/components/zd-iterable/conditions-manager.d.ts

@@ -0,0 +1,49 @@
+import { IDictionary, IEvents } from '@zeedhi/core';
+import { IComponentRender } from '../zd-component/interfaces';
+import { Column } from './column';
+import { IConditionsManager } from './interfaces';
+export type ConditionFunction = IEvents<{
+    row: IDictionary;
+    column: Column;
+}>;
+export type AppliedConditions = {
+    root: Partial<IComponentRender>;
+    children: IDictionary<Partial<IComponentRender>>;
+};
+export declare class ConditionsManager implements IConditionsManager {
+    private uniqueKey;
+    private columns;
+    /**
+     * Dictionary of rowKey ponting to Dictionary of colName pointing to Dictionary of prop pointing to the
+     * condition (applied) return value
+     */
+    private cellsApplied;
+    private factoredConditions;
+    constructor(uniqueKey: string, columns: Column[]);
+    /**
+     * Return plain conditions object
+     * @param conditions Conditions object
+     * @param parentPath Path to parent property
+     */
+    private getPlainConditions;
+    private factorConditions;
+    private createConditions;
+    /**
+     * Apply conditions
+     * @param row Datasource row
+     */
+    applyCondition(row: IDictionary<any>, column: Column, factoredConditions?: ConditionFunction): Partial<IComponentRender>;
+    /**
+     * Apply conditions on action columns
+     * @param row Datasource row
+     */
+    private applyConditions;
+    reapplyConditions(row: IDictionary<any>, columns: Column[]): {
+        [x: string]: IDictionary<AppliedConditions>;
+    };
+    getAppliedConditions({ row, column, path, }: {
+        row: IDictionary;
+        column: Column;
+        path?: string;
+    }): Partial<IComponentRender>;
+}

package/dist/types/components/zd-iterable/interfaces.d.ts

@@ -0,0 +1,103 @@
+import { Datasource, IDatasource, IDictionary, IEventParam } from '@zeedhi/core';
+import { IButton } from '..';
+import { EventDef, IComponent, IComponentEvents, IComponentRender, IComponentRenderInstance } from '../zd-component/interfaces';
+import { ISelect } from '../zd-select/interfaces';
+import { ITextInput } from '../zd-text-input/interfaces';
+import { Column } from './column';
+export interface IIterableEvents<T = IEventParam<any>> extends IComponentEvents<T> {
+    changeLayout?: EventDef<T>;
+}
+export type ColumnAlign = 'left' | 'center' | 'right';
+export type ColumnType = 'action';
+export interface IColumn extends IComponent {
+    align?: ColumnAlign;
+    label?: string;
+    width?: string;
+    maxWidth?: string;
+    minWidth?: string;
+    overflow?: string | number;
+    mask?: string;
+    type?: ColumnType;
+    actionFixed?: boolean;
+    sortable?: boolean;
+    loading?: boolean;
+    componentProps?: IComponent;
+    conditions?: IDictionary;
+    style?: IDictionary;
+    events?: IIterableEvents;
+    xlsType?: string;
+    storeData?: boolean;
+}
+export interface IIterableProps extends IComponentRender {
+    columns?: IColumn[];
+    datasource?: IDatasource;
+    pageSizes?: string[];
+    virtualScroll?: boolean;
+    virtualScrollCache?: number;
+    searchVisibleOnly?: boolean;
+}
+export interface IIterable<T = Column> extends IComponentRenderInstance, IConditionsManager {
+    columns: T[];
+    datasource: Datasource;
+    pageSizes: string[];
+    virtualScroll: boolean;
+    virtualScrollCache: number;
+    searchVisibleOnly: boolean;
+    changeLayout(event?: Event, element?: any): void;
+    setCurrentRow(row: IDictionary): void;
+    setOrder(order: string[]): Promise<any>;
+    reload(): Promise<any>;
+    getRowKey(row: IDictionary): string | number;
+    delete(row: IDictionary): Promise<any>;
+    getData(): IDictionary[];
+    callEvent(event: string, params: any): boolean;
+    getCurrentRowIndex(): number;
+    getPage(): number;
+    setPage(page: number): Promise<any>;
+    getLastPage(): number;
+    getColumn(name: string): T;
+    createColumn(column: IColumn): T;
+    updateData(data: IDictionary[]): Promise<any>;
+    changeData(data?: IDictionary[]): void;
+    findRow(key: string | number): IDictionary | undefined;
+}
+export interface IIterablePageComponent extends IComponentRender {
+    iterableComponentName?: string;
+}
+export interface IIterablePagination extends IIterablePageComponent {
+    prevIcon?: string;
+    nextIcon?: string;
+    circle?: boolean;
+    maxButtons?: number;
+}
+export interface IIterablePageSize extends ISelect {
+    iterableComponentName?: string;
+    clearable?: boolean;
+    dataText?: string | string[];
+    dataValue?: string;
+    autocomplete?: boolean;
+    showHelper?: boolean;
+    showLabel?: boolean;
+    validations?: IDictionary;
+}
+export interface IIterablePageInfo extends IIterablePageComponent {
+}
+export interface ISearch extends ITextInput {
+    iterableComponentName?: string;
+    showLabel?: boolean;
+    showHelper?: boolean;
+    appendIcon?: string;
+    lazyAttach?: boolean;
+}
+export interface IConditionsManager {
+    reapplyConditions(row: IDictionary<any>, columns?: Column[]): IDictionary<IDictionary<any>>;
+    getAppliedConditions(args: {
+        row: IDictionary;
+        column: Column;
+        path?: string;
+    }): Partial<IComponentRender>;
+}
+export interface IIterableColumnsButton extends IButton {
+    iterableComponentName?: string;
+    ignoreColumns?: string[];
+}

package/dist/types/components/zd-iterable/iterable-columns-button-controller.d.ts

@@ -0,0 +1,9 @@
+import { IEventParam } from '@zeedhi/core';
+import { Checkbox } from '../zd-checkbox/checkbox';
+import { Column } from './column';
+import { Iterable } from './iterable';
+export declare class IterableColumnsButtonController {
+    protected iterableComponent: Iterable;
+    constructor(iterableComponent: Iterable);
+    showHideColumn(column: Column, { component, event, element }: IEventParam<Checkbox>): void;
+}

package/dist/types/components/zd-iterable/iterable-columns-button.d.ts

@@ -0,0 +1,35 @@
+import { Column } from '..';
+import { Button } from '../zd-button/button';
+import { IIterableColumnsButton } from './interfaces';
+import { Iterable } from './iterable';
+/**
+ * Base class for Columns Button component
+ */
+export declare class IterableColumnsButton<T extends Column = Column> extends Button implements IIterableColumnsButton {
+    /**
+     * Iterable component name
+     */
+    iterableComponentName: string;
+    /**
+     * Iterable component name
+     */
+    iterableComponent: Iterable<T>;
+    /**
+     * Columns to be ignored
+     */
+    ignoreColumns: string[];
+    /**
+     * Component controller
+     */
+    controller: any;
+    iconName: string;
+    icon: boolean;
+    /**
+     * Creates a new Iterable Page component.
+     * @param props Iterable page component properties
+     */
+    constructor(props: IIterableColumnsButton);
+    private setIterableComponent;
+    onCreated(): void;
+    filteredColumns(): T[];
+}

package/dist/types/components/zd-iterable/iterable-controller.d.ts

@@ -0,0 +1,8 @@
+import { Iterable } from './iterable';
+export declare class IterableController {
+    private iterable;
+    private searchInValue?;
+    constructor(iterable: Iterable);
+    get searchIn(): string[] | undefined;
+    set searchIn(value: string[] | undefined);
+}

package/dist/types/components/zd-iterable/iterable-page-component.d.ts

@@ -0,0 +1,27 @@
+import { ComponentRender } from '../zd-component/component-render';
+import { IIterablePageComponent } from './interfaces';
+import { Iterable } from './iterable';
+/**
+ * Base class for Iterable Page component
+ */
+export declare class IterablePageComponent extends ComponentRender implements IIterablePageComponent {
+    /**
+     * Iterable component name
+     */
+    iterableComponentName: string;
+    /**
+     * Iterable component name
+     */
+    iterableComponent: Iterable;
+    /**
+     * Creates a new Iterable Page component.
+     * @param props Iterable page component properties
+     */
+    constructor(props: IIterablePageComponent);
+    /**
+     * Set the Iterable Component
+     * @param element Element mounted reference
+     */
+    onMounted(element: any): void;
+    private setIterableComponent;
+}

package/dist/types/components/zd-iterable/iterable-page-info.d.ts

@@ -0,0 +1,7 @@
+import { IIterablePageInfo } from './interfaces';
+import { IterablePageComponent } from './iterable-page-component';
+/**
+ * Base class for Iterable Page Info component
+ */
+export declare class IterablePageInfo extends IterablePageComponent implements IIterablePageInfo {
+}

package/dist/types/components/zd-iterable/iterable-page-size.d.ts

@@ -0,0 +1,62 @@
+import { IDictionary } from '@zeedhi/core';
+import { Select } from '../zd-select/select';
+import { IIterablePageSize } from './interfaces';
+import { Iterable } from './iterable';
+/**
+ * Base class for Iterable Page Size component
+ */
+export declare class IterablePageSize extends Select implements IIterablePageSize {
+    /**
+     * Iterable component name
+     */
+    iterableComponentName: string;
+    /**
+     * Add input clear functionality if the input isn't readonly or disabled.
+     */
+    clearable: boolean;
+    /**
+     * Field used to display values
+     */
+    dataText: string | string[];
+    /**
+     * Field used to save values
+     */
+    dataValue: string;
+    /**
+     * Enables search input
+     */
+    autocomplete: boolean;
+    /**
+     * Shows input helper.
+     */
+    showHelper: boolean;
+    /**
+     * Shows input label.
+     */
+    showLabel: boolean;
+    /**
+     * Input validations.
+     */
+    validations: IDictionary;
+    /**
+     * Iterable component name
+     */
+    iterableComponent: Iterable;
+    /**
+     * Creates a new Iterable Page component.
+     * @param props Iterable page component properties
+     */
+    constructor(props: IIterablePageSize);
+    /**
+     * Set the Iterable Component
+     * @param element Element mounted reference
+     */
+    onMounted(element: any): void;
+    private setIterableComponent;
+    /**
+     * Event trigged when component loses the focus and value changes
+     * @param value inputed value
+     */
+    selectChange(value: any, event?: Event, element?: any): void;
+    changePageSize(size: number): void;
+}

package/dist/types/components/zd-iterable/iterable-pagination.d.ts

@@ -0,0 +1,28 @@
+import { IIterablePagination } from './interfaces';
+import { IterablePageComponent } from './iterable-page-component';
+/**
+ * Base class for Iterable Pagination component
+ */
+export declare class IterablePagination extends IterablePageComponent implements IIterablePagination {
+    /**
+     * Previous button icon
+     */
+    prevIcon: string;
+    /**
+     * Next button icon
+     */
+    nextIcon: string;
+    /**
+     * Show buttons as circles
+     */
+    circle: boolean;
+    /**
+     * Delimits the maximum number of page buttons. Undefined means automatic
+     */
+    maxButtons?: number;
+    /**
+     * Creates a new Iterable Pagination.
+     * @param props Iterable pagination properties
+     */
+    constructor(props: IIterablePagination);
+}

package/dist/types/components/zd-iterable/iterable.d.ts

@@ -0,0 +1,77 @@
+import { Datasource, IDictionary } from '@zeedhi/core';
+import { ComponentRender } from '../zd-component/component-render';
+import { IComponentRender } from '../zd-component/interfaces';
+import { Column } from './column';
+import { IColumn, IIterable, IIterableEvents, IIterableProps } from './interfaces';
+/**
+ * Base class for Iterable components.
+ */
+export declare abstract class Iterable<T extends Column = Column> extends ComponentRender<IIterableProps> implements IIterable<T> {
+    /**
+     * Iterable datasource
+     */
+    datasource: Datasource;
+    columns: T[];
+    pageSizes: string[];
+    events: IIterableEvents;
+    virtualScroll: boolean;
+    virtualScrollCache: number;
+    searchVisibleOnly: boolean;
+    defaultSearchVisibleOnly: boolean;
+    private conditionsManager;
+    /**
+     * Creates a new Iterable.
+     * @param props Iterable properties
+     */
+    constructor(props: IIterableProps);
+    protected initializeDatasource(props: IIterableProps): void;
+    updateData(data: IDictionary[]): Promise<any>;
+    getAppliedConditions(args: {
+        row: IDictionary;
+        column: Column;
+        path?: string;
+    }): Partial<IComponentRender>;
+    getCurrentRowIndex(): number;
+    getPage(): number;
+    setPage(page: number): Promise<any>;
+    getLastPage(): number;
+    protected createController(): void;
+    onCreated(): void;
+    /**
+     * Retrieves columns instances
+     * @param columns Columns property
+     */
+    protected createColumns(props: IIterableProps): T[];
+    abstract createColumn(columnProps: IColumn): T;
+    /**
+     * Retrieves a columns by name
+     * @param name Column name
+     */
+    getColumn(name: string): T;
+    get pageText(): string;
+    get paginationLength(): number;
+    /**
+     * Return cells with conditions applied for each row
+     * @param columns Iterable columns
+     * @param row Datasource row
+     */
+    getCellWithAppliedConditions(columns: Column[], row: IDictionary<any>): IDictionary<IDictionary<any>>;
+    reapplyConditions(row: IDictionary<any>, columns?: Column[]): IDictionary<IDictionary<any>>;
+    reload(): Promise<any>;
+    changeData(data: IDictionary[]): void;
+    onBeforeDestroy(): void;
+    /**
+     * Dispatches change layout Event
+     * @param event DOM event
+     * @param element DOM Element
+     */
+    changeLayout(event?: Event, element?: any): void;
+    setSearch(search: string): Promise<any>;
+    setCurrentRow(row: IDictionary): void;
+    setOrder(order: string[]): Promise<any>;
+    getRowKey(row: IDictionary): any;
+    delete(row: IDictionary): Promise<any>;
+    getData(): IDictionary[];
+    protected changeDefaultSlotNames(slot: IComponentRender[]): any;
+    findRow(key: string | number): IDictionary<any> | undefined;
+}

package/dist/types/components/zd-iterable/search.d.ts

@@ -0,0 +1,31 @@
+import { TextInput } from '../zd-text-input/text-input';
+import { ISearch } from './interfaces';
+import { Iterable } from './iterable';
+/**
+ * Base class for Search component
+ */
+export declare class Search extends TextInput implements ISearch {
+    /**
+     * Iterable component name
+     */
+    iterableComponentName: string;
+    /**
+     * Iterable component name
+     */
+    iterableComponent: Iterable;
+    showLabel: boolean;
+    showHelper: boolean;
+    appendIcon: string;
+    placeholder: string;
+    lazyAttach: boolean;
+    /**
+     * Creates a new Iterable Page component.
+     * @param props Iterable page component properties
+     */
+    constructor(props: ISearch);
+    setIterableComponent(name?: string): void;
+    protected setSearch(search: string): Promise<void>;
+    debounceSetSearch: (search: string) => void;
+    get value(): string;
+    set value(value: string);
+}

package/dist/types/components/zd-iterable-component-render/interfaces.d.ts

@@ -0,0 +1,34 @@
+import { IComponentRender } from '../zd-component/interfaces';
+import { IIterableProps } from '../zd-iterable/interfaces';
+export interface IIterableComponentRenderProps extends IIterableProps {
+    rowPropName?: string;
+    componentMetadata?: IComponentRender;
+    footerSlot?: IComponentRender[];
+    toolbarSlot?: IComponentRender[];
+    errorSlot?: IComponentRender[];
+    noDataSlot?: IComponentRender[];
+    noResultSlot?: IComponentRender[];
+    height?: number | string;
+    maxHeight?: number | string;
+    minHeight?: number | string;
+    fillHeight?: boolean;
+    width?: number | string;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+}
+export interface IIterableComponentRender extends IIterableProps {
+    rowPropName: string;
+    componentMetadata?: IComponentRender;
+    footerSlot: IComponentRender[];
+    toolbarSlot: IComponentRender[];
+    errorSlot: IComponentRender[];
+    noDataSlot: IComponentRender[];
+    noResultSlot: IComponentRender[];
+    height: number | string;
+    maxHeight: number | string;
+    minHeight: number | string;
+    fillHeight: boolean;
+    width: number | string;
+    maxWidth: number | string;
+    minWidth: number | string;
+}

package/dist/types/components/zd-iterable-component-render/iterable-component-render.d.ts

@@ -0,0 +1,84 @@
+import { IDictionary } from '@zeedhi/core';
+import { IComponentRender } from '../zd-component/interfaces';
+import { Column } from '../zd-iterable/column';
+import { IColumn } from '../zd-iterable/interfaces';
+import { Iterable } from '../zd-iterable/iterable';
+import { IIterableComponentRender, IIterableComponentRenderProps } from './interfaces';
+/**
+ * Base class for IterableComponentRender component.
+ * This component uses every row returned by Iterable.datasource to render
+ * components defined by componentMetadata property.
+ * If the data inside the datasource is changed you should perform
+ * a datasource.get() to force updating the rendered components.
+ */
+export declare class IterableComponentRender extends Iterable implements IIterableComponentRender {
+    /**
+     * Components that will be rendered on toolbar slot
+     */
+    toolbarSlot: IComponentRender[];
+    /**
+     * Components that will be rendered on footer slot
+     */
+    footerSlot: IComponentRender[];
+    /**
+     * Component item definition
+     */
+    componentMetadata: IComponentRender;
+    /**
+     * Row property name
+     */
+    rowPropName: string;
+    /**
+     * Components that will be rendered in no-data case
+     */
+    noDataSlot: IComponentRender[];
+    /**
+     * Components that will be rendered in no-result case
+     */
+    noResultSlot: IComponentRender[];
+    /**
+     * Defines the component height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    height: string | number;
+    /**
+     * Defines the component min height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    minHeight: string | number;
+    /**
+     * Defines the component max height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    maxHeight: string | number;
+    /**
+     * Set component height to fill all space available
+     */
+    fillHeight: boolean;
+    /**
+     * Defines the component width. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    width: string | number;
+    /**
+     * Defines the component min width. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    minWidth: string | number;
+    /**
+     * Defines the component max height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    maxWidth: string | number;
+    /**
+     * Components that will be rendered in error case
+     */
+    errorSlot: IComponentRender[];
+    constructor(props: IIterableComponentRenderProps);
+    private addSlashes;
+    /**
+     * Returns the iterable component metadata based on row data
+     */
+    getComponentMetadata(row: IDictionary<any>): any;
+    createColumn(column: IColumn): Column;
+}

package/dist/types/components/zd-layout/interfaces.d.ts

@@ -0,0 +1,7 @@
+import { IComponentRender } from '../zd-component/interfaces';
+export interface ILayout extends IComponentRender {
+    fullHeight?: boolean;
+    scrollable?: boolean;
+    tag?: string;
+    height: string | number;
+}

package/dist/types/components/zd-layout/layout.d.ts

@@ -0,0 +1,9 @@
+import { ComponentRender } from '../zd-component/component-render';
+import { ILayout } from './interfaces';
+export declare class Layout extends ComponentRender implements ILayout {
+    fullHeight?: boolean | undefined;
+    scrollable?: boolean | undefined;
+    tag?: string;
+    height: string | number;
+    constructor(props: ILayout);
+}