@zeedhi/common 1.118.0 → 1.120.0

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

@@ -0,0 +1,149 @@
+import { TextInput } from '../zd-text-input/text-input';
+import { ITime } from './interfaces';
+/**
+ * Base class for Time Picker component.
+ */
+export declare class Time extends TextInput implements ITime {
+    /**
+     * Restricts which hours can be selected.
+     */
+    allowedHours?: any[];
+    /**
+     * Restricts which minutes can be selected.
+     */
+    allowedMinutes?: any[];
+    /**
+     * Restricts which seconds can be selected.
+     */
+    allowedSeconds?: any[];
+    /**
+     * Input auto complete.
+     */
+    autofill: boolean;
+    /**
+     * Defines the format of a time displayed in picker. Available options are ampm and 24hr.
+     */
+    timeFormat: string;
+    /**
+     * Forces 100% width.
+     */
+    fullWidth: boolean;
+    /**
+     * Maximum allowed time.
+     */
+    maxTime: string;
+    /**
+     * Minimum allowed time.
+     */
+    minTime: string;
+    /**
+     * Allows changing hour/minute with mouse scroll.
+     */
+    scrollable: boolean;
+    /**
+     * Shows the time picker.
+     */
+    showTimePicker: boolean;
+    /**
+     * Toggles the use of seconds in picker.
+     */
+    useSeconds: boolean;
+    /**
+     * Width of the picker.
+     */
+    width: number | string;
+    protected formatterFn: (...args: any) => any;
+    protected parserFn: (...args: any) => any;
+    private isoFormatValue;
+    private valueFormatInternal;
+    private displayFormatInternal;
+    /**
+     * Defines the time input format.
+     */
+    inputFormat?: string;
+    /**
+     * True when displayValue is valid
+     */
+    protected isDisplayValid: boolean;
+    protected initialMask?: string;
+    protected isSimpleDisplay: boolean;
+    protected timeError: boolean;
+    inputMode?: string | undefined;
+    /**
+     * Create a new Time Picker.
+     * @param props Time properties
+     */
+    constructor(props: ITime);
+    private getFormat;
+    get displayFormat(): string;
+    set displayFormat(value: string);
+    get valueFormat(): string;
+    set valueFormat(value: string);
+    private get isoFormat();
+    private getInitialMask;
+    formatter(value: string): string;
+    parser(value: string): any;
+    /**
+     * Triggered when date is clicked.
+     * @param event
+     * @param element
+     */
+    selectTime(time: string, event?: Event, element?: any): void;
+    get displayValue(): string;
+    set displayValue(newValue: string);
+    /**
+     * Assign the updated mask to mask property
+     */
+    updateMask(): any;
+    /**
+     * Gets the updated masked, based on displayFormat if the initial mask is undefined
+     */
+    protected getUpdatedMask(): string;
+    protected maskFormat(format: string): string;
+    setTimeValue(displayValue: string): void;
+    isValidTime(value: string, format: string | undefined, strict?: boolean): boolean;
+    get isoValue(): string;
+    set isoValue(newValue: string);
+    formatISOTimeValue(value: string): string;
+    parseISOTimeValue(value: string): any;
+    /**
+     * Checks if a time format is simple.
+     * Simple time formats are the ones that consists only of 'HH', 'mm', 'mm' or 'YYYY', and mask delimiters
+     * @param format The format to be checked
+     * @returns true if it is simple, false otherwise
+     */
+    protected isSimpleFormat(format: string): boolean;
+    timeValidation(): boolean | string;
+    timeAllowedValidation(): boolean | string;
+    click(event?: Event, element?: any): void;
+    blur(event: Event, element: any): void;
+    focus(event: Event, element: any): void;
+    /**
+     * Add date mask
+     */
+    protected addTimeMask(): void;
+    /**
+     * Removes the component mask if value is valid
+     */
+    protected removeTimeMask(): void;
+    /**
+     * Checks if value is valid according to valueFormat and if displayValue
+     * is true
+     */
+    isFullyValid(value?: string): boolean;
+    /**
+     * Last invalid value passed to formatter
+     */
+    isTimeAllowed(value?: string): boolean;
+    isSameOrAfterMin(value: string): boolean;
+    isSameOrBeforeMax(value: string): boolean;
+    isHourAllowed(value: string): boolean;
+    isMinuteAllowed(value: string): boolean;
+    isSecondAllowed(value: string): boolean;
+    clear(): void;
+    /**
+     * Converts a date format to a mask
+     */
+    private toMask;
+    getMask(): string;
+}

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

@@ -0,0 +1,6 @@
+import { IInput } from '../zd-input/interfaces';
+export type StateType = boolean | string | number | null | object;
+export interface IToggleable extends IInput {
+    falseValue?: StateType;
+    trueValue?: StateType;
+}

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

@@ -0,0 +1,21 @@
+import { Input } from '../zd-input/input';
+import { IToggleable, StateType } from './interfaces';
+/**
+ * Base class for Toggleable inputs.
+ */
+export declare class Toggleable extends Input implements IToggleable {
+    /**
+     * Value for falsy state
+     */
+    falseValue: StateType;
+    /**
+     * Value for truthy state
+     */
+    trueValue: StateType;
+    /**
+     * Create a new Toggleable input.
+     * @param props Toggleable properties
+     */
+    constructor(props: IToggleable);
+    toggleValue(): void;
+}

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

@@ -0,0 +1,18 @@
+import { IEventParam } from '@zeedhi/core';
+import { IComponentRender } from '../zd-component/interfaces';
+import { Tooltip } from './tooltip';
+export type ITooltipEvent = IEventParam<Tooltip>;
+export interface ITooltip extends IComponentRender {
+    bottom?: boolean;
+    disabled?: boolean;
+    label?: string;
+    left?: boolean;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    nudge?: number | string;
+    openOnClick?: boolean;
+    openOnFocus?: boolean;
+    openOnHover?: boolean;
+    right?: boolean;
+    top?: boolean;
+}

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

@@ -0,0 +1,57 @@
+import { ComponentRender } from '../zd-component/component-render';
+import { ITooltip } from './interfaces';
+/**
+ * Base class for Tooltip component.
+ */
+export declare class Tooltip extends ComponentRender implements ITooltip {
+    /**
+     * Aligns the component towards the bottom
+     */
+    bottom: boolean;
+    /**
+     * Disables the tooltip
+     */
+    disabled: boolean;
+    label: string;
+    /**
+     * Aligns the component towards the left
+     */
+    left: boolean;
+    /**
+     * Sets the maximum width for the content
+     */
+    maxWidth?: number | string;
+    /**
+     * Sets the minimum width for the content
+     */
+    minWidth?: number | string;
+    /**
+     * Nudge the content
+     */
+    nudge: number | string;
+    /**
+     * Open the tooltip on activator click
+     */
+    openOnClick: boolean;
+    /**
+     * Open the tooltip on activator focus
+     */
+    openOnFocus: boolean;
+    /**
+     * Open the tooltip on activator hover
+     */
+    openOnHover: boolean;
+    /**
+     * Nudge the content to the top
+     */
+    right: boolean;
+    /**
+     * Nudge the content to the top
+     */
+    top: boolean;
+    /**
+     * Create a new Tooltip
+     * @param props Tooltip definition
+     */
+    constructor(props: ITooltip);
+}

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

@@ -0,0 +1,107 @@
+import { IDatasource, IDictionary, IEventParam } from '@zeedhi/core';
+import { ITreeComponent } from '../../utils';
+import { EventDef, IComponentEvents, IComponentRender, IComponentRenderInstance } from '../zd-component/interfaces';
+import { Tree } from './tree';
+export interface ITreeNodeModel<T> {
+    title: string;
+    isLeaf?: boolean;
+    children?: ITreeNodeModel<T>[];
+    isExpanded?: boolean;
+    isSelected?: boolean;
+    isDraggable?: boolean;
+    isSelectable?: boolean;
+    data?: T;
+}
+export interface ITreeNode<T> extends ITreeNodeModel<T> {
+    isFirstChild?: boolean;
+    isLastChild?: boolean;
+    isVisible?: boolean;
+    level?: number;
+    ind?: number;
+    path?: number[];
+    pathStr?: string;
+    children?: ITreeNode<T>[];
+}
+export interface ICursorPosition<T> {
+    node: ITreeNode<T>;
+    placement: 'before' | 'inside' | 'after';
+}
+export interface ITreeSelectEvent extends IEventParam<Tree> {
+    nodes: ITreeNode<IDictionary>[];
+}
+export interface ITreeDropEvent extends IEventParam<Tree> {
+    nodes: ITreeNode<IDictionary>[];
+    position: ICursorPosition<IDictionary>;
+}
+export interface ITreeClickEvent extends IEventParam<Tree> {
+    node: ITreeNode<IDictionary>;
+}
+export interface ITreeConditionComponent extends IComponentRender {
+    conditions?: IDictionary;
+}
+export interface ITreeEvents extends IComponentEvents<any> {
+    onNodeDrop?: EventDef<ITreeDropEvent>;
+    onNodeSelect?: EventDef<ITreeSelectEvent>;
+    onNodeClick?: EventDef<ITreeClickEvent>;
+    onNodeDblClick?: EventDef<ITreeClickEvent>;
+    onNodeCheck?: EventDef<ITreeSelectEvent>;
+}
+export interface ITreeProps extends IComponentRender {
+    nodes?: ITreeNodeModel<IDictionary>[];
+    itemIconName?: string;
+    groupIconName?: string;
+    openedIconName?: string;
+    closedIconName?: string;
+    allowMultiSelect?: boolean;
+    allowDragDrop?: boolean;
+    afterTitleSlot?: ITreeConditionComponent;
+    toolbarSlot?: IComponentRender[];
+    titleSlot?: ITreeConditionComponent[];
+    events?: ITreeEvents;
+    height?: number | string;
+    maxHeight?: number | string;
+    minHeight?: number | string;
+    fillHeight?: boolean;
+    width?: number | string;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    datasource?: IDatasource;
+    parentField?: string;
+    titleField?: string;
+    dataField?: string;
+    checkedField?: string;
+    openLevelOnLoad?: number | boolean;
+    checkbox?: boolean;
+    disableCheckbox?: (args: {
+        node: ITreeNode<IDictionary>;
+        component: Tree;
+    }) => boolean;
+}
+export interface ITree extends IComponentRenderInstance, ITreeComponent {
+    nodes: ITreeNodeModel<IDictionary>[];
+    itemIconName: string;
+    groupIconName: string;
+    openedIconName: string;
+    closedIconName: string;
+    allowMultiSelect: boolean;
+    allowDragDrop: boolean;
+    afterTitleSlot?: ITreeConditionComponent;
+    toolbarSlot: IComponentRender[];
+    titleSlot: ITreeConditionComponent[];
+    events: ITreeEvents;
+    height: number | string;
+    maxHeight: number | string;
+    minHeight: number | string;
+    fillHeight: boolean;
+    width: number | string;
+    maxWidth: number | string;
+    minWidth: number | string;
+    titleField: string;
+    dataField: string;
+    checkedField: string;
+    checkbox: boolean;
+    disableCheckbox?: (args: {
+        node: ITreeNode<IDictionary>;
+        component: Tree;
+    }) => boolean;
+}

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

@@ -0,0 +1,161 @@
+import { Datasource, Event, IDictionary, IEvents } from '@zeedhi/core';
+import { ComponentRender } from '../zd-component/component-render';
+import { IComponent, IComponentRender, IComponentRenderInstance } from '../zd-component/interfaces';
+import { ICursorPosition, ITree, ITreeConditionComponent, ITreeNode, ITreeNodeModel, ITreeProps } from './interfaces';
+export declare class Tree extends ComponentRender implements ITree {
+    /** Tree nodes */
+    nodesValue: ITreeNodeModel<IDictionary>[];
+    /** Tree Item icon name */
+    itemIconName: string;
+    /** Tree Group icon name */
+    groupIconName: string;
+    /** Tree opened group icon name */
+    openedIconName: string;
+    /** Tree closed group icon name */
+    closedIconName: string;
+    /** Allow selecting multiple nodes */
+    allowMultiSelect: boolean;
+    /** Allow dragging nodes */
+    allowDragDrop: boolean;
+    /** Render a component in front of the node title */
+    afterTitleSlot?: ITreeConditionComponent;
+    /**
+     * Components that will be rendered on toolbar slot
+     */
+    toolbarSlot: 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 on title slot
+     */
+    titleSlot: ITreeConditionComponent[];
+    /** Datasource object */
+    datasource: Datasource;
+    /** Datasource parent field */
+    parentField: string;
+    /** Datasource title field */
+    titleField: string;
+    /** Datasource data field */
+    dataField: string;
+    /** Datasource checked field */
+    checkedField: string;
+    /**
+     * Defines if the tree will be opened or not (true/false) or if it should open only until a specific level
+     */
+    openLevelOnLoad: number | boolean;
+    /**
+     * Allow row check
+     */
+    checkbox: boolean;
+    /**
+     * Function to check if node check should be disabled
+     */
+    disableCheckbox?: (args: {
+        node: ITreeNode<IDictionary>;
+        component: Tree;
+    }) => boolean;
+    /** SlVueTree component */
+    private tree;
+    /** SlVueTree component */
+    private treeDataStructure?;
+    /**
+     * Defines if should wait and not execute GET method when Datasource is created
+     */
+    private lazyLoad;
+    /**
+     * Dictionary of nodePath ponting to Dictionary of path pointing to the condition (applied) return value
+     */
+    private appliedConditions;
+    private factoredConditions;
+    /**
+     * Creates a new instance of LabelsTree
+     * @param props Image Link props
+     */
+    constructor(props: ITreeProps);
+    /**
+     * Initialize all the properties of the declared nodes (reactivity)
+     */
+    initNodes(nodes: ITreeNodeModel<IDictionary>[], override?: IDictionary): ITreeNodeModel<IDictionary>[];
+    /** Nodes */
+    get nodes(): ITreeNodeModel<IDictionary>[];
+    set nodes(value: ITreeNodeModel<IDictionary>[]);
+    onCreated(): Promise<void>;
+    getCheckedNodes(): ITreeNode<IDictionary<any>>[];
+    /** Returns the selected nodes */
+    get selectedNodes(): ITreeNode<IDictionary>[];
+    private createDataStructure;
+    /** create nodes from datasource object */
+    createNodesFromDatasource(buildTree?: boolean): void;
+    private createNodeFromRow;
+    private createChildrenNodes;
+    /** Insert nodes by the current cursor position */
+    insertNode(newNode: ITreeNodeModel<IDictionary>): void;
+    /** Import multiples nodes by the current cursor position */
+    importNodes(nodes: ITreeNodeModel<IDictionary>[]): void;
+    /** Remove selected node */
+    removeSelected(): void;
+    /** Update selected node */
+    updateNodeData(node: ITreeNode<IDictionary>, value: IDictionary): void;
+    setTree(tree: any): void;
+    /**
+     * Return plain conditions object
+     * @param conditions Conditions object
+     * @param parentPath Path to parent property
+     */
+    protected getPlainConditions(conditions: IDictionary<any>, parentPath?: string): IDictionary<string>;
+    protected createConditions(children: ITreeConditionComponent[], parentPath?: string): void;
+    protected applyCondition(node: ITreeNode<any>, factoredConditions: IEvents<ITreeNode<IDictionary>>): IDictionary<any>;
+    protected applyChildCondition(node: ITreeNode<any>, factoredConditions?: IDictionary<IEvents<ITreeNode<IDictionary<any>>>>): IDictionary<any>;
+    reapplyConditions(node: ITreeNode<any>): IDictionary;
+    private filterObject;
+    private deleteAccessorProps;
+    protected updateActionInstance(instanceName: string, newComponent: IComponent): ComponentRender<IComponentRender>;
+    getSlotComponent(slot: IComponentRender | IComponentRender[], node: ITreeNode<IDictionary>, parentPath?: string): (IComponentRender | IComponentRenderInstance)[];
+    /** Triggers when dragging nodes have been dropped */
+    nodeDrop(nodes: ITreeNode<IDictionary>[], position: ICursorPosition<IDictionary>, event?: Event, element?: any): void;
+    /** Triggers when a node has been selected/deselected */
+    nodeSelect(nodes: ITreeNode<IDictionary>[], event?: Event, element?: any): void;
+    /** Handle click event on node */
+    nodeClick(node: ITreeNode<IDictionary>, event?: Event, element?: any): void;
+    /** Handle dblclick event on node */
+    nodeDblClick(node: ITreeNode<IDictionary>, event?: Event, element?: any): void;
+    /** Triggers when a node has been checked/unchecked */
+    nodeCheck(node: ITreeNode<IDictionary>, event?: Event, element?: HTMLElement): void;
+    clearSelection(nodes?: ITreeNodeModel<IDictionary<any>>[]): void;
+    getNode(path: number[]): ITreeNodeModel<IDictionary<any>> | undefined;
+    getParentNode(node: ITreeNode<IDictionary>): any;
+    private searchPath;
+    callDisableCheckbox(node: ITreeNode<IDictionary>): boolean;
+}

package/dist/types/components/zd-tree-grid/index.d.ts

@@ -0,0 +1,6 @@
+export * from './interfaces';
+export * from './iterable-tree';
+export * from './keymap-tree';
+export * from './tree-data-selector';
+export * from './tree-grid';
+export * from './tree-data-navigator';

package/dist/types/components/zd-tree-grid/interfaces.d.ts

@@ -0,0 +1,35 @@
+import { IDictionary } from '@zeedhi/core';
+import { ITreeComponent, ITreeDataStructure } from '../../utils/tree-data-structure/interfaces';
+import { IDataSelector, IGrid, IGridProps } from '../zd-grid';
+export interface ITreeDataSelector extends IDataSelector {
+    selectChildren(row: IDictionary<any>): void;
+    unselectChildren(row: IDictionary<any>): void;
+}
+export interface IIterableTree {
+    onMounted(element: HTMLElement): void;
+    buildTree(doGet?: boolean): void;
+    setViewUpdateScrollData(fn: () => void): void;
+    updateScrollData(): void;
+}
+export interface ITreeGridProps extends IGridProps {
+    parentField?: string;
+    openLevelOnLoad?: number | boolean;
+    fetchOnDemand?: boolean;
+    fieldHasChild?: string;
+    flat?: boolean;
+    detach?: boolean;
+    lazyLoad?: boolean;
+}
+export interface ITreeGrid extends ITreeComponent, IGrid, ITreeDataSelector, IIterableTree {
+    flat: boolean;
+    lazyLoad: boolean;
+    treeDataStructure: ITreeDataStructure;
+    getChildren(row: IDictionary): IDictionary[];
+    findDataIndex(data: IDictionary<any>[], value: any): number;
+    getParentRow(row: IDictionary): IDictionary;
+    buildTreeStructure(): void;
+    resetTree(): void;
+    filterRootData(): Promise<any>;
+    navigateToggle(collapse: boolean): void;
+    toggleExpand(row: IDictionary<any>, rowIndex?: number): Promise<IDictionary<any>[] | undefined>;
+}

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

@@ -0,0 +1,10 @@
+import { IIterableTree, ITreeGrid } from './interfaces';
+export declare class IterableTree implements IIterableTree {
+    private treeGrid;
+    viewUpdateScrollData?: () => void;
+    constructor(treeGrid: ITreeGrid);
+    onMounted(): void;
+    buildTree(doGet?: boolean): void;
+    setViewUpdateScrollData(fn: () => void): void;
+    updateScrollData(): void;
+}

package/dist/types/components/zd-tree-grid/keymap-tree.d.ts

@@ -0,0 +1,7 @@
+import { IKeyMap } from '@zeedhi/core';
+import { Component } from '../zd-component/component';
+import { IKeyMapConfig } from '../zd-grid';
+import { ITreeGrid } from './interfaces';
+export declare class KeyMapTree implements IKeyMapConfig<ITreeGrid> {
+    getMap(instance: Component & ITreeGrid): IKeyMap;
+}

package/dist/types/components/zd-tree-grid/tree-data-navigator.d.ts

@@ -0,0 +1,10 @@
+import { IDataNavigator, VerticalDirection } from '../zd-grid';
+import { ITreeGrid } from './interfaces';
+export declare class TreeDataNavigator implements IDataNavigator {
+    private treeGrid;
+    private dataNavigator;
+    constructor(treeGrid: ITreeGrid);
+    navigateDatasource(direction: VerticalDirection): void;
+    navigatePageUp(): void;
+    navigatePageDown(): void;
+}

package/dist/types/components/zd-tree-grid/tree-data-selector.d.ts

@@ -0,0 +1,18 @@
+import { IDictionary } from '@zeedhi/core';
+import { ITreeDataSelector, ITreeGrid } from './interfaces';
+export declare class TreeDataSelector implements ITreeDataSelector {
+    private treeGrid;
+    private dataSelector;
+    constructor(treeGrid: ITreeGrid);
+    private removeDuplicates;
+    selectChildren(row: IDictionary<any>): void;
+    unselectChildren(row: IDictionary<any>): void;
+    private selectParents;
+    private unselectParents;
+    selectRow(row: IDictionary<any>, select: boolean): void;
+    selectAll(isSelected: boolean): void;
+    toggleRow(row: IDictionary): void;
+    callDisableSelection(row: IDictionary): boolean;
+    selectClick(row: IDictionary<any>, isSelected: boolean, event: Event, element?: HTMLElement): void;
+    selectAllClick(isSelected: boolean, event: Event, element?: HTMLElement): void;
+}