@talxis/base-controls 1.2406.2

package/dist/components/Grid/core/interfaces/IGridContext.d.ts

@@ -0,0 +1,4 @@
+import { Grid } from "../model/Grid";
+export interface IGridContext {
+    gridInstance: Grid;
+}

package/dist/components/Grid/core/model/Grid.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="@types/powerapps-component-framework" />
+import { IDatasetProperty } from "../../../../interfaces";
+import { StringProps } from "../../../../types";
+import { Filtering } from "../../filtering/model/Filtering";
+import { IEntityRecord, IGrid, IGridTranslations } from "../../interfaces";
+import { Paging } from "../../paging/model/Paging";
+import { Selection } from "../../selection/model/Selection";
+import { Sorting } from "../../sorting/Sorting";
+import { IGridColumn } from "../interfaces/IGridColumn";
+import { RecordUpdateService } from "../services/RecordUpdateService/model/RecordUpdateService";
+import { Metadata } from "./Metadata";
+export declare class Grid {
+    private _props;
+    private _dataset;
+    private _pcfContext;
+    private _columns;
+    private _records;
+    private _labels;
+    private _shouldRerender;
+    private _dependencies;
+    constructor(props: IGrid, labels: Required<StringProps<IGridTranslations>>);
+    get isNavigationEnabled(): boolean;
+    get isEditable(): boolean;
+    get parameters(): import("../../interfaces").IGridParameters;
+    get error(): boolean | undefined;
+    get errorMessage(): string | undefined;
+    get labels(): Required<StringProps<IGridTranslations>>;
+    get dataset(): IDatasetProperty;
+    get pcfContext(): ComponentFramework.Context<any>;
+    get props(): IGrid;
+    get columns(): IGridColumn[];
+    get records(): IEntityRecord[];
+    get recordUpdateService(): RecordUpdateService;
+    get sorting(): Sorting;
+    get metadata(): Metadata;
+    get filtering(): Filtering;
+    get selection(): Selection;
+    get paging(): Paging;
+    get shouldRerender(): boolean;
+    get loading(): boolean;
+    get state(): ComponentFramework.Dictionary | undefined;
+    get isNested(): boolean;
+    openDatasetItem(entityReference: ComponentFramework.EntityReference): void;
+    updateDependencies(props: IGrid): void;
+    refreshColumns(): Promise<IGridColumn[]>;
+    refreshRecords(): IEntityRecord[];
+    private _isColumnEditable;
+    private _isColumnRequired;
+    private _isColumnSortable;
+    private _isColumnFilterable;
+}

package/dist/components/Grid/core/model/GridDependency.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="@types/powerapps-component-framework" />
+import { Grid } from "./Grid";
+export declare class GridDependency {
+    protected _grid: Grid;
+    protected _refreshCallbacks: Map<string, () => any>;
+    constructor(grid: Grid);
+    addRefreshCallback(id: string, callback: () => any): void;
+    removeRefreshCallback(id: string): void;
+    onDependenciesUpdated(): void;
+    protected _triggerRefreshCallbacks(): void;
+    protected get _dataset(): import("../../../../interfaces").IDatasetProperty;
+    protected get _pcfContext(): ComponentFramework.Context<any>;
+}

package/dist/components/Grid/core/model/Metadata.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="@types/powerapps-component-framework" />
+import { IGridColumn } from "../interfaces/IGridColumn";
+import { GridDependency } from "./GridDependency";
+export declare class Metadata extends GridDependency {
+    get(column: IGridColumn): Promise<ComponentFramework.PropertyHelper.EntityMetadata>;
+    getOptions(column: IGridColumn): Promise<[number | boolean, ComponentFramework.PropertyHelper.OptionMetadata[]]>;
+}

package/dist/components/Grid/core/services/RecordUpdateService/controllers/useRecordUpdateServiceController.d.ts

@@ -0,0 +1,14 @@
+import { IUpdatedRecord } from "../model/RecordUpdateService";
+interface IRecordUpdateServiceController {
+    isDirty: boolean;
+    hasInvalidRecords: boolean;
+    updatedRecords: IUpdatedRecord[];
+    saveAll: () => Promise<boolean>;
+    clearAll: () => void;
+    record(recordId: string): {
+        get: () => IUpdatedRecord | undefined;
+        setValue: (columnName: string, value: any) => void;
+    };
+}
+export declare const useRecordUpdateServiceController: () => IRecordUpdateServiceController;
+export {};

package/dist/components/Grid/core/services/RecordUpdateService/model/RecordUpdateService.d.ts

@@ -0,0 +1,30 @@
+import { IEntityColumn, IEntityRecord } from "../../../../interfaces";
+import { Grid } from "../../../model/Grid";
+import { GridDependency } from "../../../model/GridDependency";
+export interface IUpdatedRecord extends Omit<IEntityRecord, 'save'> {
+    columns: Map<string, IEntityColumn>;
+    isValid: (columnKey: string) => boolean;
+    getOriginalValue: (columnKey: string) => any;
+    getOriginalFormattedValue: (columnKey: string) => any;
+    getOriginalFormattedPrimaryNameValue: () => any;
+    save: () => Promise<boolean>;
+    clear: () => void;
+}
+export declare class RecordUpdateService extends GridDependency {
+    private _updatedRecords;
+    private _internalRecordMap;
+    constructor(grid: Grid);
+    get updatedRecords(): IUpdatedRecord[];
+    get isDirty(): boolean;
+    get hasInvalidRecords(): boolean;
+    record(recordId: string): {
+        get: () => IUpdatedRecord | undefined;
+        setValue: (columnKey: string, value: any, doNotPropagateToDatasetRecord?: boolean) => void;
+    };
+    saveAll(): Promise<boolean>;
+    clearAll(): Promise<void>;
+    onDependenciesUpdated(): void;
+    private _getEntityColumnByKey;
+    private _isReadOnlyChangeEditor;
+    private _isEqual;
+}

package/dist/components/Grid/filtering/components/FilterCallout/FilterCallout.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ICalloutProps } from '@fluentui/react';
+import { IGridColumn } from '../../../core/interfaces/IGridColumn';
+export interface IFilterCallout extends ICalloutProps {
+    column: IGridColumn;
+    onDismiss: () => void;
+}
+export declare const FilterCallout: (props: IFilterCallout) => JSX.Element;

package/dist/components/Grid/filtering/components/FilterCallout/components/ConditionOperator/ConditionOperator.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { IGridColumn } from '../../../../../core/interfaces/IGridColumn';
+interface IConditionOperator {
+    column: IGridColumn;
+}
+export declare const ConditionOperator: (props: IConditionOperator) => JSX.Element;
+export {};

package/dist/components/Grid/filtering/components/FilterCallout/components/ConditionValue/ConditionValue.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { IGridColumn } from "../../../../../core/interfaces/IGridColumn";
+interface IConditionValue {
+    column: IGridColumn;
+}
+export declare const ConditionValue: (props: IConditionValue) => JSX.Element;
+export {};

package/dist/components/Grid/filtering/components/FilterCallout/components/ConditionValue/model/ConditionComponentValue.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import { DataType } from "../../../../../../core/enums/DataType";
+import { IColumnFilterConditionController } from "../../../../../controller/useColumnFilterConditionController";
+export declare class ConditionComponentValue {
+    private _columnFilterConditionControllerRef;
+    private _conditionUtils;
+    constructor(columnFilterConditionControllerRef: React.MutableRefObject<IColumnFilterConditionController>);
+    get column(): {
+        key: string;
+        attributeName: string;
+        isPrimary?: boolean | undefined;
+        dataType?: DataType | undefined;
+        displayName?: string | undefined;
+        entityAliasName?: string | undefined;
+        isFilterable?: boolean | undefined;
+        isSortable?: boolean | undefined;
+        isSorted?: boolean | undefined;
+        isFiltered?: boolean | undefined;
+        isSortedDescending?: boolean | undefined;
+        isEditable?: boolean | undefined;
+        isResizable?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        width?: number | undefined;
+    };
+    get(): any;
+    set(value: any): void;
+    private get _columnFilterConditionController();
+    private get _value();
+    private get _operator();
+}

package/dist/components/Grid/filtering/components/FilterCallout/styles.d.ts

@@ -0,0 +1,35 @@
+export declare const filterCalloutStyles: import("@fluentui/react").IProcessedStyleSet<{
+    controls: {
+        display: string;
+        flexDirection: string;
+        gap: number;
+        flexGrow: number;
+    };
+    root: {
+        minHeight: number;
+        padding: number;
+        '.ms-Callout-main': {
+            display: string;
+            flexDirection: string;
+            gap: number;
+        };
+        '.TALXIS__combobox__root, [class*="TALXIS__textfield__root"], [class*="TALXIS__tag-picker__root"]': {
+            padding: string;
+        };
+    };
+    title: {
+        fontWeight: number;
+        flexGrow: number;
+    };
+    header: {
+        display: string;
+        i: {
+            fontSize: number;
+        };
+    };
+    footer: {
+        display: string;
+        gap: number;
+        justifyContent: string;
+    };
+}>;

package/dist/components/Grid/filtering/constants.d.ts

@@ -0,0 +1,5 @@
+import { DatasetConditionOperator } from "../core/enums/ConditionOperator";
+export declare const OPERATORS: {
+    type: DatasetConditionOperator;
+    key: string;
+}[];

package/dist/components/Grid/filtering/controller/useColumnFilterConditionController.d.ts

@@ -0,0 +1,19 @@
+import { DatasetConditionOperator } from "../../core/enums/ConditionOperator";
+import { IGridColumn } from "../../core/interfaces/IGridColumn";
+export interface IColumnFilterConditionController {
+    isAppliedToDataset: boolean;
+    column: IGridColumn;
+    value: {
+        valid: boolean;
+        get: () => any;
+        set: (value: any) => void;
+    };
+    operator: {
+        get: () => DatasetConditionOperator | undefined;
+        set: (operator: DatasetConditionOperator) => void;
+    };
+    remove: () => void;
+    save: () => Promise<boolean>;
+    clear: () => void;
+}
+export declare const useColumnFilterConditionController: (column: IGridColumn) => IColumnFilterConditionController | null;

package/dist/components/Grid/filtering/model/Condition.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="@types/powerapps-component-framework" />
+import { DatasetConditionOperator } from "../../core/enums/ConditionOperator";
+import { IGridColumn } from "../../core/interfaces/IGridColumn";
+import { Grid } from "../../core/model/Grid";
+import { GridDependency } from "../../core/model/GridDependency";
+export declare class Condition extends GridDependency {
+    private _column;
+    private _isAppliedToDataset;
+    private _conditionExpression;
+    private _isRemoved?;
+    private _conditionUtils;
+    private _isValid;
+    private _inicializationPromise;
+    private _initialized;
+    constructor(grid: Grid, column: IGridColumn);
+    init(): Promise<boolean>;
+    get isRemoved(): boolean | undefined;
+    get column(): IGridColumn;
+    get isAppliedToDataset(): boolean;
+    get isValid(): boolean;
+    getExpression(): Promise<{
+        attributeName: string;
+        conditionOperator: ComponentFramework.PropertyHelper.DataSetApi.Types.ConditionOperator;
+        value: string | string[];
+        entityAliasName?: string | undefined;
+    }>;
+    save(): Promise<boolean>;
+    remove(): void;
+    clear(): void;
+    get operator(): {
+        get: () => DatasetConditionOperator;
+        set: (conditionOperator: DatasetConditionOperator) => void;
+    };
+    get value(): {
+        get: () => any;
+        set: (value: any) => void;
+        isValid: () => Promise<boolean>;
+    };
+    private _get;
+    private _set;
+    private _attributeNameDecorator;
+    private _valueDecorator;
+    private _operatorDecorator;
+    private _getDefault;
+    private get _filterExpression();
+    private _getConditionFromFilterExpression;
+}

package/dist/components/Grid/filtering/model/Filtering.d.ts

@@ -0,0 +1,11 @@
+import { IGridColumn } from "../../core/interfaces/IGridColumn";
+import { GridDependency } from "../../core/model/GridDependency";
+import { Condition } from "./Condition";
+export declare class Filtering extends GridDependency {
+    private _conditions;
+    save(): Promise<boolean>;
+    clear(): void;
+    condition(column: IGridColumn): Promise<Condition>;
+    private get _filterExpression();
+    private _getColumnKeyFromCondition;
+}

package/dist/components/Grid/filtering/utils/FilteringUtilts.d.ts

@@ -0,0 +1,34 @@
+import { DatasetConditionOperator } from "../../core/enums/ConditionOperator";
+export declare class FilteringUtils {
+    static condition(): {
+        operator: (conditionOperator?: DatasetConditionOperator) => {
+            textFieldOperators: {
+                type: DatasetConditionOperator;
+                key: string;
+            }[];
+            numberOperators: {
+                type: DatasetConditionOperator;
+                key: string;
+            }[];
+            dateOperators: {
+                type: DatasetConditionOperator;
+                key: string;
+            }[];
+            multipleOptionSetOperators: {
+                type: DatasetConditionOperator;
+                key: string;
+            }[];
+            fileOperators: {
+                type: DatasetConditionOperator;
+                key: string;
+            }[];
+            allowsOnlyFreeText: boolean;
+            allowsOnlyNumber: boolean;
+            doesNotAllowValue: boolean;
+        };
+        value: (conditionOperator: DatasetConditionOperator) => {
+            isEditable: boolean;
+            isManuallyEditable: boolean;
+        };
+    };
+}

package/dist/components/Grid/interfaces.d.ts

@@ -0,0 +1,254 @@
+/// <reference types="@types/powerapps-component-framework" />
+import { IDatasetProperty, IParameters, ITwoOptionsProperty } from "../../interfaces";
+import { IComponent, IOutputs, ITranslations } from "../../interfaces/context";
+export interface IGrid extends IComponent<IGridParameters, IGridOutputs, IGridTranslations> {
+}
+export interface IEntityColumn extends ComponentFramework.PropertyHelper.DataSetApi.Column {
+    isResizable?: boolean;
+    isFilterable?: boolean;
+    isEditable?: boolean;
+    isRequired?: boolean;
+}
+export interface IEntityRecord extends ComponentFramework.PropertyHelper.DataSetApi.EntityRecord {
+    setValue: (columnName: string, value: any) => void;
+    save: () => Promise<void>;
+}
+export interface IGridParameters extends IParameters {
+    EnableEditing?: Omit<ITwoOptionsProperty, 'attributes'>;
+    EnablePagination?: Omit<ITwoOptionsProperty, 'attributes'>;
+    EnableFiltering?: Omit<ITwoOptionsProperty, 'attributes'>;
+    EnableSorting?: Omit<ITwoOptionsProperty, 'attributes'>;
+    EnableNavigation?: Omit<ITwoOptionsProperty, 'attributes'>;
+    IsNested?: Omit<ITwoOptionsProperty, 'attributes'>;
+    SelectableRows?: ComponentFramework.PropertyTypes.EnumProperty<"none" | "single" | "multiple">;
+    Grid: IDatasetProperty;
+}
+export interface IGridOutputs extends IOutputs {
+}
+export interface IGridTranslations extends ITranslations {
+    "condition-none": {
+        [LCID: number]: string;
+    };
+    "condition-equal": {
+        [LCID: number]: string;
+    };
+    "condition-notequal": {
+        [LCID: number]: string;
+    };
+    "condition-greaterthan": {
+        [LCID: number]: string;
+    };
+    "condition-lessthan": {
+        [LCID: number]: string;
+    };
+    "condition-greaterequal": {
+        [LCID: number]: string;
+    };
+    "condition-lessequal": {
+        [LCID: number]: string;
+    };
+    "condition-like": {
+        [LCID: number]: string;
+    };
+    "condition-notlike": {
+        [LCID: number]: string;
+    };
+    "condition-null": {
+        [LCID: number]: string;
+    };
+    "condition-notnull": {
+        [LCID: number]: string;
+    };
+    "condition-beginwith": {
+        [LCID: number]: string;
+    };
+    "condition-doesnotbeginwith": {
+        [LCID: number]: string;
+    };
+    "condition-endswith": {
+        [LCID: number]: string;
+    };
+    "condition-doesnotendwith": {
+        [LCID: number]: string;
+    };
+    "condition-yesterday": {
+        [LCID: number]: string;
+    };
+    "condition-today": {
+        [LCID: number]: string;
+    };
+    "condition-tomorrow": {
+        [LCID: number]: string;
+    };
+    "condition-last7days": {
+        [LCID: number]: string;
+    };
+    "condition-next7days": {
+        [LCID: number]: string;
+    };
+    "condition-lastweek": {
+        [LCID: number]: string;
+    };
+    "condition-thisweek": {
+        [LCID: number]: string;
+    };
+    "condition-lastmonth": {
+        [LCID: number]: string;
+    };
+    "condition-thismonth": {
+        [LCID: number]: string;
+    };
+    "condition-on": {
+        [LCID: number]: string;
+    };
+    "condition-onorbefore": {
+        [LCID: number]: string;
+    };
+    "condition-onorafter": {
+        [LCID: number]: string;
+    };
+    "condition-lastyear": {
+        [LCID: number]: string;
+    };
+    "condition-thisyear": {
+        [LCID: number]: string;
+    };
+    "condition-lastxdays": {
+        [LCID: number]: string;
+    };
+    "condition-nextxdays": {
+        [LCID: number]: string;
+    };
+    "condition-lastxmonths": {
+        [LCID: number]: string;
+    };
+    "condition-nextxmonths": {
+        [LCID: number]: string;
+    };
+    "condition-contains": {
+        [LCID: number]: string;
+    };
+    "condition-infiscalperiodandyear": {
+        [LCID: number]: string;
+    };
+    "condition-above": {
+        [LCID: number]: string;
+    };
+    "condition-under": {
+        [LCID: number]: string;
+    };
+    "condition-notunder": {
+        [LCID: number]: string;
+    };
+    "condition-aboveorequal": {
+        [LCID: number]: string;
+    };
+    "condition-underorequal": {
+        [LCID: number]: string;
+    };
+    "condition-containvalues": {
+        [LCID: number]: string;
+    };
+    "condition-doesnotcontainvalues": {
+        [LCID: number]: string;
+    };
+    "filtermenu-filterby": {
+        [LCID: number]: string;
+    };
+    "filtermenu-applybutton": {
+        [LCID: number]: string;
+    };
+    "filtermenu-clearbutton": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-sorttext-a-z": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-sorttext-z-a": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-sortdate-a-z": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-sortdate-z-a": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-sortnumber-a-z": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-sortnumber-z-a": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-sorttwooption-a-z": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-sorttwooption-z-a": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-sorttwooption-joint": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-filterby": {
+        [LCID: number]: string;
+    };
+    "filtersortmenu-clearfilter": {
+        [LCID: number]: string;
+    };
+    "paging-pages": {
+        [LCID: number]: string;
+    };
+    "paging-of": {
+        [LCID: number]: string;
+    };
+    "paging-firstpage": {
+        [LCID: number]: string;
+    };
+    "paging-previouspage": {
+        [LCID: number]: string;
+    };
+    "paging-page": {
+        [LCID: number]: string;
+    };
+    "paging-nextpage": {
+        [LCID: number]: string;
+    };
+    "paging-lastpage": {
+        [LCID: number]: string;
+    };
+    "norecordsfound": {
+        [LCID: number]: string;
+    };
+    "saving-changenotification": {
+        [LCID: number]: string;
+    };
+    "saving-save": {
+        [LCID: number]: string;
+    };
+    "saving-saving": {
+        [LCID: number]: string;
+    };
+    "saving-changepreview-title": {
+        [LCID: number]: string;
+    };
+    "saving-validation-error": {
+        [LCID: number]: string;
+    };
+    "validation-input-value": {
+        [LCID: number]: string;
+    };
+    "validation-email": {
+        [LCID: number]: string;
+    };
+    "validation-url": {
+        [LCID: number]: string;
+    };
+    "validation-date": {
+        [LCID: number]: string;
+    };
+    "validation-number": {
+        [LCID: number]: string;
+    };
+    "no-name": {
+        [LCID: number]: string;
+    };
+}

package/dist/components/Grid/paging/components/Paging/Paging.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const Paging: () => JSX.Element;

package/dist/components/Grid/paging/components/Paging/styles.d.ts

@@ -0,0 +1,35 @@
+import { ITheme } from "@fluentui/react";
+export declare const getPagingStyles: (theme: ITheme) => import("@fluentui/react").IProcessedStyleSet<{
+    root: {
+        display: string;
+        flexWrap: string;
+        justifyContent: string;
+    };
+    pagination: {
+        '.ms-CommandBar': {
+            paddingLeft: number;
+            paddingRight: number;
+        };
+    };
+    currentPageBtn: {
+        '.ms-Button-label': {
+            color: string;
+        };
+    };
+    pageSizeBtnWrapper: {
+        flexGrow: number;
+        display: string;
+        '.ms-Button-label': {
+            whiteSpace: string;
+        };
+        '.ms-Button': {
+            height: number;
+        };
+    };
+    pageSizeOption: {
+        '& .is-checked': {
+            backgroundColor: string;
+            fontWeight: number;
+        };
+    };
+}>;

package/dist/components/Grid/paging/controllers/usePagingController.d.ts

@@ -0,0 +1,16 @@
+interface IPagingController {
+    pageNumber: number;
+    pageSize: number;
+    totalResultCount: number;
+    hasPreviousPage: boolean;
+    hasNextPage: boolean;
+    pageFirstRecordOrder: number;
+    pageLastRecordOrder: number;
+    loadNextPage: () => void;
+    loadPreviousPage: () => void;
+    loadExactPage: (pageNumber: number) => void;
+    setPageSize: (pageSize: number) => void;
+    reset: () => void;
+}
+export declare const usePagingController: () => IPagingController;
+export {};

package/dist/components/Grid/paging/model/Paging.d.ts

@@ -0,0 +1,15 @@
+import { GridDependency } from "../../core/model/GridDependency";
+export declare class Paging extends GridDependency {
+    get pageNumber(): number;
+    get pageSize(): number;
+    get totalResultCount(): number;
+    get hasPreviousPage(): boolean;
+    get hasNextPage(): boolean;
+    get pageFirstRecordOrder(): number;
+    get pageLastRecordOrder(): number;
+    loadNextPage(): void;
+    loadPreviousPage(): void;
+    loadExactPage(pageNumber: number): void;
+    setPageSize(pageSize: number): void;
+    reset(): void;
+}