@zeedhi/common 1.115.0 → 3.0.1

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

@@ -0,0 +1,223 @@
+import { IDictionary } from '@zeedhi/core';
+import { ComponentRender } from '../zd-component/component-render';
+import { Form } from '../zd-form/form';
+import { IInput, IInputEvents } from './interfaces';
+import { IFormGrid } from '../zd-form/interfaces';
+/**
+ * Base class for Input component.
+ */
+export declare class Input extends ComponentRender implements IInput {
+    /**
+     * Input content alignment.
+     */
+    align: string;
+    /**
+     * Always show error messages even if showHelper is false.
+     */
+    alwaysShowError: boolean;
+    /**
+     * Input auto complete.
+     */
+    autofill: boolean;
+    /**
+     * Add input clear functionality if the input isn't readonly or disabled.
+     */
+    clearable: boolean;
+    /**
+     * Applies specified color to the control.
+     * It can be the name of material or css color in hex.
+     */
+    color: string;
+    /**
+     * Defines smaller input.
+     */
+    dense: boolean;
+    /**
+     * Removes the ability to click or target the input.
+     */
+    disabled: boolean;
+    /**
+     * Defines input events.
+     */
+    events: IInputEvents;
+    /**
+     * Hint text.
+     */
+    hint: string;
+    /**
+     * Defines the input label.
+     */
+    label: string;
+    /**
+     * Applies a custom character mask to the input.
+     */
+    mask?: any;
+    /**
+     * Input max character length.
+     */
+    maxLength: number;
+    /**
+     * Forces hint to always be visible.
+     */
+    persistentHint: boolean;
+    /**
+     * Sets the input’s placeholder text.
+     */
+    placeholder: string;
+    /**
+     * Puts input in readonly state.
+     */
+    readonly: boolean;
+    /**
+     * Reverses the input orientation.
+     */
+    reverse: boolean;
+    /**
+     * Rules that will validate the input value.
+     */
+    rules: ((value?: any) => boolean | string)[];
+    /**
+     * Shows input border.
+     */
+    showBorder: boolean;
+    /**
+     * Shows input helper.
+     */
+    showHelper: boolean;
+    /**
+     * Shows input label.
+     */
+    showLabel: boolean;
+    /**
+     * Show rules details in input.
+     */
+    autoHintDetails: boolean;
+    /**
+     * Used to watch a value from store.
+     */
+    storePath: string;
+    /**
+     * Input validations.
+     */
+    validations: IDictionary<IDictionary<string | number>>;
+    /**
+     * Optional validation method assigned by view layer.
+     */
+    private viewValidate?;
+    /**
+     * Reset validation method assigned by view layer.
+     */
+    private viewResetValidation?;
+    /**
+     * Parsed field rules.
+     */
+    protected parsedValidations: IDictionary<(value?: any) => boolean | string>;
+    protected formatterFn: (...args: any) => any;
+    protected parserFn: (...args: any) => any;
+    protected internalDisplayValue: string;
+    protected internalValue: any;
+    formParent?: Form;
+    grid: IFormGrid;
+    /**
+     * Creates a new Input.
+     * @param props Input properties
+     */
+    constructor(props: IInput);
+    onCreated(): void;
+    /**
+     * Validates input.
+     */
+    validate(): Promise<string[]>;
+    /**
+     * Sets view validation method.
+     */
+    setViewValidate(viewValidate: (silent?: boolean) => Promise<string[]>): void;
+    /**
+     * Sets view reset validation method.
+     */
+    setViewResetValidation(viewResetValidation: () => void): void;
+    /**
+     * Reset all form validation errors.
+     * @throws Will throw if viewResetValidation is undefined
+     */
+    resetValidation(): void;
+    /**
+     * Adds parsed validations based on field validations.
+     * @param validations Field validations
+     */
+    private parseValidations;
+    /**
+     * Adds input validation.
+     * @param name Validation name
+     * @param config Validation config
+     */
+    addValidation(name: string, config?: IDictionary<any>): void;
+    /**
+     * Removes input validation.
+     * @param name Validation name
+     */
+    removeValidation(name: string): void;
+    /**
+     * Removes all input validation.
+     */
+    clearValidations(): void;
+    /**
+     * Updates input rules.
+     */
+    protected updateRules(): void;
+    /**
+     * Input value.
+     */
+    get value(): any;
+    set value(value: any);
+    /**
+     * Input displayed value.
+     */
+    get displayValue(): any;
+    set displayValue(value: any);
+    /**
+     * Retrieves a formatted value.
+     * @param value Any value
+     * @returns A Formatted value
+     */
+    formatter(value: any): any;
+    /**
+     * Retrieves a parsed value.
+     * @param value Any value
+     * @returns A parsed value
+     */
+    parser(value: any): any;
+    /**
+     * Checks the input value are valid to all applied rules.
+     * @returns Input is valid
+     */
+    isValid(value?: any): boolean;
+    private lastChangeValue;
+    /**
+     * Triggered when the input value changes.
+     * @param event DOM event
+     * @param element Element clicked
+     */
+    change(event?: Event, element?: any): void;
+    protected lastInputValue: any;
+    protected callInputEvent: ({ event, element, component }: IDictionary) => void;
+    /**
+     * Triggered when the data is inputted.
+     * @param event DOM event
+     * @param element Element focused
+     */
+    input(event?: Event, element?: any): void;
+    /**
+     * Triggered when a keyboard key is released.
+     * @param event DOM event
+     * @param element Element that lost the focus
+     */
+    keyup(event?: Event, element?: any): void;
+    /**
+     * Triggered when the user presses a key on the keyboard.
+     * @param event DOM event
+     * @param element Element that lost the focus
+     */
+    keydown(event?: Event, element?: any): void;
+    private getFormParent;
+}

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

@@ -0,0 +1,38 @@
+import { IDictionary, IEventParam } from '@zeedhi/core';
+import { EventDef, IComponentEvents, IComponentRender } from '../zd-component/interfaces';
+import { Input } from './input';
+import { IFormGrid } from '../zd-form/interfaces';
+export type IInputEvent = IEventParam<Input>;
+export interface IInputEvents<T = IEventParam<any>> extends IComponentEvents<T> {
+    change?: EventDef<T>;
+    input?: EventDef<T>;
+    keydown?: EventDef<T>;
+    keyup?: EventDef<T>;
+}
+export interface IInput extends IComponentRender {
+    align?: string;
+    alwaysShowError?: boolean;
+    autofill?: boolean;
+    clearable?: boolean;
+    color?: string;
+    dense?: boolean;
+    disabled?: boolean;
+    displayValue?: any;
+    events?: IInputEvents;
+    hint?: string;
+    label?: string;
+    mask?: any;
+    maxLength?: number;
+    persistentHint?: boolean;
+    autoHintDetails?: boolean;
+    placeholder?: string;
+    readonly?: boolean;
+    reverse?: boolean;
+    showBorder?: boolean;
+    showHelper?: boolean;
+    showLabel?: boolean;
+    storePath?: string;
+    validations?: IDictionary<IDictionary<string | number>>;
+    value?: any;
+    grid?: IFormGrid;
+}

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);
+}