cax-design-system 1.0.0

package/table/components/table-radio-button/table-radio-button.d.ts

@@ -0,0 +1,29 @@
+import { ElementRef, ChangeDetectorRef } from '@angular/core';
+import { Table } from '../../table';
+import { Nullable } from 'cax-design-system/ts-helpers';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TableRadioButton {
+    dt: Table;
+    cd: ChangeDetectorRef;
+    disabled: boolean | undefined;
+    value: any;
+    index: number | undefined;
+    inputId: string | undefined;
+    name: string | undefined;
+    ariaLabel: string | undefined;
+    inputViewChild: Nullable<ElementRef>;
+    checked: boolean | undefined;
+    focused: boolean | undefined;
+    subscription: Subscription;
+    constructor(dt: Table, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    onClick(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableRadioButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableRadioButton, "cax-tableRadioButton", never, { "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "index": { "alias": "index"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "name": { "alias": "name"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_index: unknown;
+}

package/table/directives/cancel-editable-row.directive.d.ts

@@ -0,0 +1,11 @@
+import { Table } from '../table';
+import { EditableRow } from './editable-row.directive';
+import * as i0 from "@angular/core";
+export declare class CancelEditableRow {
+    dt: Table;
+    editableRow: EditableRow;
+    constructor(dt: Table, editableRow: EditableRow);
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CancelEditableRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CancelEditableRow, "[caxCancelEditableRow]", never, {}, {}, never, never, true, never>;
+}

package/table/directives/content-menu-row.directive.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { Table } from '../table';
+import { TableService } from '../table.service';
+import * as i0 from "@angular/core";
+export declare class ContextMenuRow {
+    dt: Table;
+    tableService: TableService;
+    private el;
+    data: any;
+    index: number | undefined;
+    caxContextMenuRowDisabled: boolean | undefined;
+    selected: boolean | undefined;
+    subscription: Subscription | undefined;
+    constructor(dt: Table, tableService: TableService, el: ElementRef);
+    onContextMenu(event: Event): void;
+    isEnabled(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuRow, "[caxContextMenuRow]", never, { "data": { "alias": "caxContextMenuRow"; "required": false; }; "index": { "alias": "caxContextMenuRowIndex"; "required": false; }; "caxContextMenuRowDisabled": { "alias": "caxContextMenuRowDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxContextMenuRowDisabled: unknown;
+}

package/table/directives/editable-column.directive.d.ts

@@ -0,0 +1,40 @@
+import { OnChanges, AfterViewInit, OnDestroy, ElementRef, NgZone, SimpleChanges } from '@angular/core';
+import { Table } from '../table';
+import * as i0 from "@angular/core";
+export declare class EditableColumn implements OnChanges, AfterViewInit, OnDestroy {
+    dt: Table;
+    el: ElementRef;
+    zone: NgZone;
+    data: any;
+    field: any;
+    rowIndex: number | undefined;
+    caxEditableColumnDisabled: boolean | undefined;
+    pFocusCellSelector: string | undefined;
+    overlayEventListener: any;
+    constructor(dt: Table, el: ElementRef, zone: NgZone);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    onClick(event: MouseEvent): void;
+    openCell(): void;
+    closeEditingCell(completed: any, event: Event): void;
+    onEnterKeyDown(event: KeyboardEvent): void;
+    onTabKeyDown(event: KeyboardEvent): void;
+    onEscapeKeyDown(event: KeyboardEvent): void;
+    onShiftKeyDown(event: KeyboardEvent): void;
+    onArrowDown(event: KeyboardEvent): void;
+    onArrowUp(event: KeyboardEvent): void;
+    onArrowLeft(event: KeyboardEvent): void;
+    onArrowRight(event: KeyboardEvent): void;
+    findCell(element: any): any;
+    moveToPreviousCell(event: KeyboardEvent): void;
+    moveToNextCell(event: KeyboardEvent): void;
+    findPreviousEditableColumn(cell: any): HTMLTableCellElement | null;
+    findNextEditableColumn(cell: any): HTMLTableCellElement | null;
+    findNextEditableColumnByIndex(cell: Element, index: number): Element;
+    findPrevEditableColumnByIndex(cell: Element, index: number): Element;
+    isEnabled(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableColumn, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EditableColumn, "[caxEditableColumn]", never, { "data": { "alias": "caxEditableColumn"; "required": false; }; "field": { "alias": "caxEditableColumnField"; "required": false; }; "rowIndex": { "alias": "caxEditableColumnRowIndex"; "required": false; }; "caxEditableColumnDisabled": { "alias": "caxEditableColumnDisabled"; "required": false; }; "pFocusCellSelector": { "alias": "pFocusCellSelector"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxEditableColumnDisabled: unknown;
+}

package/table/directives/editable-row.directive.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class EditableRow {
+    el: ElementRef;
+    data: any;
+    caxEditableRowDisabled: boolean | undefined;
+    constructor(el: ElementRef);
+    isEnabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EditableRow, "[caxEditableRow]", never, { "data": { "alias": "caxEditableRow"; "required": false; }; "caxEditableRowDisabled": { "alias": "caxEditableRowDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxEditableRowDisabled: unknown;
+}

package/table/directives/frozen-column.directive.d.ts

@@ -0,0 +1,16 @@
+import { AfterViewChecked, ElementRef, NgZone } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FrozenColumn implements AfterViewChecked {
+    private el;
+    private zone;
+    get frozen(): boolean;
+    set frozen(val: boolean);
+    alignFrozen: string;
+    constructor(el: ElementRef, zone: NgZone);
+    ngAfterViewChecked(): void;
+    recalculateColumns(): void;
+    _frozen: boolean;
+    updateStickyPosition(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FrozenColumn, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FrozenColumn, "[caxFrozenColumn]", never, { "frozen": { "alias": "frozen"; "required": false; }; "alignFrozen": { "alias": "alignFrozen"; "required": false; }; }, {}, never, never, true, never>;
+}

package/table/directives/init-editable-row.directive.d.ts

@@ -0,0 +1,11 @@
+import { Table } from '../table';
+import { EditableRow } from './editable-row.directive';
+import * as i0 from "@angular/core";
+export declare class InitEditableRow {
+    dt: Table;
+    editableRow: EditableRow;
+    constructor(dt: Table, editableRow: EditableRow);
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitEditableRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InitEditableRow, "[caxInitEditableRow]", never, {}, {}, never, never, true, never>;
+}

package/table/directives/reorderable-column.directive.d.ts

@@ -0,0 +1,32 @@
+import { AfterViewInit, OnDestroy, Renderer2, ElementRef, NgZone } from '@angular/core';
+import { VoidListener } from 'cax-design-system/ts-helpers';
+import { Table } from '../table';
+import * as i0 from "@angular/core";
+export declare class ReorderableColumn implements AfterViewInit, OnDestroy {
+    private platformId;
+    private renderer;
+    dt: Table;
+    el: ElementRef;
+    zone: NgZone;
+    caxReorderableColumnDisabled: boolean | undefined;
+    dragStartListener: VoidListener;
+    dragOverListener: VoidListener;
+    dragEnterListener: VoidListener;
+    dragLeaveListener: VoidListener;
+    mouseDownListener: VoidListener;
+    constructor(platformId: any, renderer: Renderer2, dt: Table, el: ElementRef, zone: NgZone);
+    ngAfterViewInit(): void;
+    bindEvents(): void;
+    unbindEvents(): void;
+    onMouseDown(event: any): void;
+    onDragStart(event: any): void;
+    onDragOver(event: any): void;
+    onDragEnter(event: any): void;
+    onDragLeave(event: any): void;
+    onDrop(event: any): void;
+    isEnabled(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReorderableColumn, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ReorderableColumn, "[caxReorderableColumn]", never, { "caxReorderableColumnDisabled": { "alias": "caxReorderableColumnDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxReorderableColumnDisabled: unknown;
+}

package/table/directives/reorderable-row-handle.directive.d.ts

@@ -0,0 +1,9 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ReorderableRowHandle implements AfterViewInit {
+    el: ElementRef;
+    constructor(el: ElementRef);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReorderableRowHandle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ReorderableRowHandle, "[caxReorderableRowHandle]", never, {}, {}, never, never, true, never>;
+}

package/table/directives/reorderable-row.directive.d.ts

@@ -0,0 +1,34 @@
+import { AfterViewInit, Renderer2, ElementRef, NgZone } from '@angular/core';
+import { VoidListener } from 'cax-design-system/ts-helpers';
+import { Table } from '../table';
+import * as i0 from "@angular/core";
+export declare class ReorderableRow implements AfterViewInit {
+    private renderer;
+    dt: Table;
+    el: ElementRef;
+    zone: NgZone;
+    index: number | undefined;
+    caxReorderableRowDisabled: boolean | undefined;
+    mouseDownListener: VoidListener;
+    dragStartListener: VoidListener;
+    dragEndListener: VoidListener;
+    dragOverListener: VoidListener;
+    dragLeaveListener: VoidListener;
+    dropListener: VoidListener;
+    constructor(renderer: Renderer2, dt: Table, el: ElementRef, zone: NgZone);
+    ngAfterViewInit(): void;
+    bindEvents(): void;
+    unbindEvents(): void;
+    onMouseDown(event: Event): void;
+    isHandleElement(element: HTMLElement): boolean;
+    onDragStart(event: DragEvent): void;
+    onDragEnd(event: DragEvent): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    isEnabled(): boolean;
+    onDrop(event: DragEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReorderableRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ReorderableRow, "[caxReorderableRow]", never, { "index": { "alias": "caxReorderableRow"; "required": false; }; "caxReorderableRowDisabled": { "alias": "caxReorderableRowDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxReorderableRowDisabled: unknown;
+}

package/table/directives/resizable-column.directive.d.ts

@@ -0,0 +1,35 @@
+import { AfterViewInit, OnDestroy, Renderer2, ElementRef, NgZone } from '@angular/core';
+import { VoidListener } from 'cax-design-system/ts-helpers';
+import { Table } from '../table';
+import * as i0 from "@angular/core";
+export declare class ResizableColumn implements AfterViewInit, OnDestroy {
+    private document;
+    private platformId;
+    private renderer;
+    dt: Table;
+    el: ElementRef;
+    zone: NgZone;
+    caxResizableColumnDisabled: boolean | undefined;
+    resizer: HTMLSpanElement | undefined;
+    resizerMouseDownListener: VoidListener;
+    resizerTouchStartListener: VoidListener;
+    resizerTouchMoveListener: VoidListener;
+    resizerTouchEndListener: VoidListener;
+    documentMouseMoveListener: VoidListener;
+    documentMouseUpListener: VoidListener;
+    constructor(document: Document, platformId: any, renderer: Renderer2, dt: Table, el: ElementRef, zone: NgZone);
+    ngAfterViewInit(): void;
+    bindDocumentEvents(): void;
+    unbindDocumentEvents(): void;
+    onMouseDown(event: MouseEvent): void;
+    onTouchStart(event: TouchEvent): void;
+    onTouchMove(event: TouchEvent): void;
+    onDocumentMouseMove(event: MouseEvent): void;
+    onDocumentMouseUp(event: MouseEvent): void;
+    onTouchEnd(event: TouchEvent): void;
+    isEnabled(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableColumn, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableColumn, "[caxResizableColumn]", never, { "caxResizableColumnDisabled": { "alias": "caxResizableColumnDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxResizableColumnDisabled: unknown;
+}

package/table/directives/row-group-header.directive.d.ts

@@ -0,0 +1,9 @@
+import { Table } from '../table';
+import * as i0 from "@angular/core";
+export declare class RowGroupHeader {
+    dt: Table;
+    constructor(dt: Table);
+    get getFrozenRowGroupHeaderStickyPosition(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowGroupHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RowGroupHeader, "[caxRowGroupHeader]", never, {}, {}, never, never, true, never>;
+}

package/table/directives/row-toggler.directive.d.ts

@@ -0,0 +1,13 @@
+import { Table } from '../table';
+import * as i0 from "@angular/core";
+export declare class RowToggler {
+    dt: Table;
+    data: any;
+    caxRowTogglerDisabled: boolean | undefined;
+    constructor(dt: Table);
+    onClick(event: Event): void;
+    isEnabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowToggler, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RowToggler, "[caxRowToggler]", never, { "data": { "alias": "caxRowToggler"; "required": false; }; "caxRowTogglerDisabled": { "alias": "caxRowTogglerDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxRowTogglerDisabled: unknown;
+}

package/table/directives/save-editable-row.directive.d.ts

@@ -0,0 +1,11 @@
+import { Table } from '../table';
+import { EditableRow } from './editable-row.directive';
+import * as i0 from "@angular/core";
+export declare class SaveEditableRow {
+    dt: Table;
+    editableRow: EditableRow;
+    constructor(dt: Table, editableRow: EditableRow);
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SaveEditableRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SaveEditableRow, "[caxSaveEditableRow]", never, {}, {}, never, never, true, never>;
+}

package/table/directives/selectable-row-double-click.directive.d.ts

@@ -0,0 +1,22 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { Table } from '../table';
+import { TableService } from '../table.service';
+import * as i0 from "@angular/core";
+export declare class SelectableRowDblClick implements OnInit, OnDestroy {
+    dt: Table;
+    tableService: TableService;
+    data: any;
+    index: number | undefined;
+    caxSelectableRowDisabled: boolean | undefined;
+    selected: boolean | undefined;
+    subscription: Subscription | undefined;
+    constructor(dt: Table, tableService: TableService);
+    ngOnInit(): void;
+    onClick(event: Event): void;
+    isEnabled(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableRowDblClick, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectableRowDblClick, "[caxSelectableRowDblClick]", never, { "data": { "alias": "caxSelectableRowDblClick"; "required": false; }; "index": { "alias": "caxSelectableRowIndex"; "required": false; }; "caxSelectableRowDisabled": { "alias": "caxSelectableRowDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxSelectableRowDisabled: unknown;
+}

package/table/directives/selectable-row.directive.d.ts

@@ -0,0 +1,37 @@
+import { OnInit, OnDestroy, ElementRef } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { Table } from '../table';
+import { TableService } from '../table.service';
+import * as i0 from "@angular/core";
+export declare class SelectableRow implements OnInit, OnDestroy {
+    dt: Table;
+    tableService: TableService;
+    private el;
+    data: any;
+    index: number | undefined;
+    caxSelectableRowDisabled: boolean | undefined;
+    selected: boolean | undefined;
+    subscription: Subscription | undefined;
+    constructor(dt: Table, tableService: TableService, el: ElementRef);
+    setRowTabIndex(): 0 | -1;
+    ngOnInit(): void;
+    onClick(event: Event): void;
+    onTouchEnd(event: Event): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onArrowDownKey(event: KeyboardEvent): void;
+    onArrowUpKey(event: KeyboardEvent): void;
+    onEnterKey(event: KeyboardEvent): void;
+    onEndKey(event: KeyboardEvent): void;
+    onHomeKey(event: KeyboardEvent): void;
+    onSpaceKey(event: any): void;
+    focusRowChange(firstFocusableRow: any, currentFocusedRow: any): void;
+    findLastSelectableRow(): any;
+    findFirstSelectableRow(): any;
+    findNextSelectableRow(row: HTMLTableRowElement): HTMLTableRowElement | null;
+    findPrevSelectableRow(row: HTMLTableRowElement): HTMLTableRowElement | null;
+    isEnabled(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectableRow, "[caxSelectableRow]", never, { "data": { "alias": "caxSelectableRow"; "required": false; }; "index": { "alias": "caxSelectableRowIndex"; "required": false; }; "caxSelectableRowDisabled": { "alias": "caxSelectableRowDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxSelectableRowDisabled: unknown;
+}

package/table/directives/sortable-column.directive.d.ts

@@ -0,0 +1,24 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { Table } from '../table';
+import * as i0 from "@angular/core";
+export declare class SortableColumn implements OnInit, OnDestroy {
+    dt: Table;
+    field: string | undefined;
+    caxSortableColumnDisabled: boolean | undefined;
+    sorted: boolean | undefined;
+    sortOrder: string | undefined;
+    subscription: Subscription | undefined;
+    constructor(dt: Table);
+    ngOnInit(): void;
+    updateSortState(): void;
+    onClick(event: MouseEvent): void;
+    onEnterKey(event: MouseEvent): void;
+    isEnabled(): boolean;
+    isFilterElement(element: HTMLElement): boolean;
+    private isFilterElementIconOrButton;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortableColumn, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SortableColumn, "[caxSortableColumn]", never, { "field": { "alias": "caxSortableColumn"; "required": false; }; "caxSortableColumnDisabled": { "alias": "caxSortableColumnDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_caxSortableColumnDisabled: unknown;
+}

package/table/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="cax-design-system/table" />
+export * from './public_api';

package/table/public_api.d.ts

@@ -0,0 +1,28 @@
+export * from './table';
+export * from './table.interface';
+export * from './columnfilter.interface';
+export * from './table.module';
+export * from './components/cell-editor/cell-editor';
+export * from './components/column-filter/column-filter';
+export * from './components/column-filter-form-element/column-filter-form-element';
+export * from './components/sort-icon/sort-icon';
+export * from './components/table-body/table-body';
+export * from './components/table-checkbox/table-checkbox';
+export * from './components/table-header-checkbox/table-header-checkbox';
+export * from './components/table-radio-button/table-radio-button';
+export * from './directives/cancel-editable-row.directive';
+export * from './directives/content-menu-row.directive';
+export * from './directives/editable-column.directive';
+export * from './directives/editable-row.directive';
+export * from './directives/frozen-column.directive';
+export * from './directives/init-editable-row.directive';
+export * from './directives/reorderable-column.directive';
+export * from './directives/reorderable-row-handle.directive';
+export * from './directives/reorderable-row.directive';
+export * from './directives/resizable-column.directive';
+export * from './directives/row-group-header.directive';
+export * from './directives/row-toggler.directive';
+export * from './directives/save-editable-row.directive';
+export * from './directives/selectable-row-double-click.directive';
+export * from './directives/selectable-row.directive';
+export * from './directives/sortable-column.directive';