@teselagen/ui 0.8.6-beta.23 → 0.8.6-beta.25

package/DataTable/EditabelCell.d.ts

@@ -0,0 +1,7 @@
+export function EditableCell({ cancelEdit, dataTest, finishEdit, isNumeric, initialValue }: {
+    cancelEdit: any;
+    dataTest: any;
+    finishEdit: any;
+    isNumeric: any;
+    initialValue: any;
+}): import("react/jsx-runtime").JSX.Element;

package/DataTable/defaultProps.d.ts

@@ -0,0 +1,43 @@
+import { noop } from 'lodash-es';
+declare namespace _default {
+    export { noop as addFilters };
+    export let className: string;
+    export { noop as clearFilters };
+    export { noop as contextMenu };
+    export let disabled: boolean;
+    export let entities: never[];
+    export let extraClasses: string;
+    export let filters: never[];
+    export let isCopyable: boolean;
+    export { noop as isEntityDisabled };
+    export let isLoading: boolean;
+    export let isSimple: boolean;
+    export let isSingleSelect: boolean;
+    export let maxHeight: number;
+    export let noHeader: boolean;
+    export let noSelect: boolean;
+    export let noUserSelect: boolean;
+    export { noop as onDeselect };
+    export { noop as onMultiRowSelect };
+    export { noop as onRowClick };
+    export { noop as onRowSelect };
+    export { noop as onSingleRowSelect };
+    export let page: number;
+    export let pageSize: number;
+    export let reduxFormExpandedEntityIdMap: {};
+    export let reduxFormSearchInput: string;
+    export let reduxFormSelectedEntityIdMap: {};
+    export { noop as removeSingleFilter };
+    export let resized: never[];
+    export { noop as resizePersist };
+    export { noop as setFilter };
+    export { noop as setOrder };
+    export { noop as setPage };
+    export { noop as setPageSize };
+    export { noop as setSearchTerm };
+    export let showCount: boolean;
+    export let style: {};
+    export let withCheckboxes: boolean;
+    export let withSort: boolean;
+}
+export default _default;

package/DataTable/utils/computePresets.d.ts

@@ -0,0 +1 @@
+export default function computePresets(props?: {}): import('lodash').Dictionary<any>;

package/DataTable/utils/convertSchema.d.ts

@@ -1,3 +1,23 @@
-export function mergeSchemas(_originalSchema: any, _overrideSchema: any): any;
+type Field = {
+    type?: string;
+    displayName?: string;
+    path?: string;
+    filterDisabled?: boolean;
+    sortDisabled?: boolean;
+};
+type Schema = {
+    fields: (Field | string)[];
+};
+type CompleteField = Field & {
+    type: string;
+    displayName: string;
+    path: string;
+};
+type CompleteSchema = {
+    fields: CompleteField[];
+};
+declare const convertSchema: (schema: Schema) => CompleteSchema;
+export declare function mergeSchemas(_originalSchema: Schema, _overrideSchema: Schema): {
+    fields: CompleteField[];
+};
 export default convertSchema;
-declare function convertSchema(schema: any): any;

package/DataTable/utils/formatPasteData.d.ts

@@ -1,5 +1,11 @@
-export function formatPasteData({ schema, newVal, path }: {
-    schema: any;
-    newVal: any;
-    path: any;
-}): any;
+import { Schema } from './types/Schema';
+type GenericSelectValue = {
+    __strVal: string;
+    __genSelCol: string;
+};
+export declare const formatPasteData: ({ schema, newVal, path }: {
+    schema: Schema;
+    newVal: GenericSelectValue | string | number | boolean | null | undefined;
+    path: string;
+}) => string | number | boolean | null | undefined;
+export {};

package/DataTable/utils/getAllRows.d.ts

@@ -1 +1,4 @@
-export function getAllRows(e: any): any;
+import { RefObject } from '../../../../../node_modules/react';
+export declare const getAllRows: (tableRef: RefObject<{
+    tableRef: HTMLDivElement;
+}>) => NodeListOf<Element> | undefined;

package/DataTable/utils/getCellCopyText.d.ts

@@ -1 +1 @@
-export function getCellCopyText(cellWrapper: any): any[];
+export declare const getCellCopyText: (cellWrapper: HTMLElement | null) => (string | null | undefined)[];

package/DataTable/utils/getCellInfo.d.ts

@@ -1,17 +1,22 @@
-export function getCellInfo({ columnIndex, columnPath, rowId, schema, entities, rowIndex, isEntityDisabled, entity }: {
-    columnIndex: any;
-    columnPath: any;
-    rowId: any;
-    schema: any;
-    entities: any;
-    rowIndex: any;
-    isEntityDisabled: any;
-    entity: any;
-}): {
+import { Entity } from './types/Entity';
+export declare const getCellInfo: <T extends Entity>({ columnIndex, columnPath, rowId, schema, entities, rowIndex, isEntityDisabled, entity }: {
+    columnIndex: number;
+    columnPath: string;
+    rowId: string | number;
+    schema: {
+        fields: {
+            path: string;
+        }[];
+    };
+    entities: T[];
+    rowIndex: number;
+    isEntityDisabled: (entity: T) => boolean;
+    entity: T;
+}) => {
     cellId: string;
-    cellIdAbove: any;
-    cellIdToRight: any;
-    cellIdBelow: any;
-    cellIdToLeft: any;
-    rowDisabled: any;
+    cellIdAbove: string | 0;
+    cellIdToRight: string;
+    cellIdBelow: string | 0;
+    cellIdToLeft: string;
+    rowDisabled: boolean;
 };

package/DataTable/utils/getFieldPathToField.d.ts

@@ -1 +1,5 @@
-export function getFieldPathToField(schema: any): {};
+import { Field } from './types/Field';
+import { Schema } from './types/Schema';
+export declare const getFieldPathToField: (schema: Schema) => {
+    [path: string]: Field;
+};

package/DataTable/utils/getIdOrCodeOrIndex.d.ts

@@ -1 +1,2 @@
-export function getIdOrCodeOrIndex(record: any, rowIndex: any): any;
+import { Entity } from './types/Entity';
+export declare const getIdOrCodeOrIndex: (record: Entity, rowIndex?: number) => string | number;

package/DataTable/utils/getLastSelectedEntity.d.ts

@@ -1 +1,7 @@
-export function getLastSelectedEntity(idMap: any): undefined;
+import { Entity } from './types/Entity';
+export declare const getLastSelectedEntity: (idMap: {
+    [id: string]: {
+        time: number;
+        entity: Entity;
+    };
+}) => undefined;

package/DataTable/utils/getNewEntToSelect.d.ts

@@ -1,6 +1,7 @@
-export function getNewEntToSelect({ type, lastSelectedIndex, entities, isEntityDisabled }: {
-    type: any;
-    lastSelectedIndex: any;
-    entities: any;
-    isEntityDisabled: any;
-}): any;
+import { Entity } from './types/Entity';
+export declare const getNewEntToSelect: ({ type, lastSelectedIndex, entities, isEntityDisabled }: {
+    type: "up" | "down";
+    lastSelectedIndex: number;
+    entities: Entity[];
+    isEntityDisabled?: (entity: Entity) => boolean;
+}) => Entity | undefined;

package/DataTable/utils/getRowCopyText.d.ts

@@ -1 +1 @@
-export function getRowCopyText(rowEl: any, { specificColumn }?: {}): (string | any[])[];
+export function getRowCopyText(rowEl: any, { specificColumn }?: {}): (string | (string | null | undefined)[])[];

package/DataTable/utils/handleCopyColumn.d.ts

@@ -1 +1 @@
-export function handleCopyColumn(e: any, cellWrapper: any, selectedRecords: any): void;
+export function handleCopyColumn(tableRef: any, cellWrapper: any, selectedRecords: any): void;

package/DataTable/utils/handleCopyTable.d.ts

@@ -1 +1 @@
-export function handleCopyTable(e: any, opts: any): void;
+export function handleCopyTable(tableRef: any, opts: any): void;

package/DataTable/utils/initializeHasuraWhereAndFilter.d.ts

@@ -1 +1,22 @@
-export function initializeHasuraWhereAndFilter(additionalFilter: any, where: {} | undefined, currentParams: any): void;
+type Filter = {
+    [key: string]: {
+        _eq: string | number | boolean;
+    } | {
+        _in: (string | number | boolean)[];
+    } | {
+        _gt: number;
+    } | {
+        _lt: number;
+    } | {
+        _gte: number;
+    } | {
+        _lte: number;
+    };
+};
+type Where = {
+    _and?: Filter[];
+    _or?: Filter[];
+};
+type CurrentParams = object;
+export declare function initializeHasuraWhereAndFilter(additionalFilter: ((where: Where, currentParams: CurrentParams) => Filter | void) | Filter | undefined | null, where: Where | undefined, currentParams: CurrentParams): void;
+export {};

package/DataTable/utils/isBottomRightCornerOfRectangle.d.ts

@@ -1,8 +1,10 @@
-export function isBottomRightCornerOfRectangle({ cellId, selectionGrid, lastRowIndex, lastCellIndex, entityMap, pathToIndex }: {
-    cellId: any;
-    selectionGrid: any;
-    lastRowIndex: any;
-    lastCellIndex: any;
-    entityMap: any;
-    pathToIndex: any;
-}): boolean | undefined;
+export declare const isBottomRightCornerOfRectangle: ({ cellId, selectionGrid, lastRowIndex, lastCellIndex, entityMap, pathToIndex }: {
+    cellId: string;
+    selectionGrid: (string | undefined)[][];
+    lastRowIndex: number;
+    lastCellIndex: number;
+    entityMap: Record<string, {
+        i: number;
+    }>;
+    pathToIndex: Record<string, number>;
+}) => boolean | undefined;

package/DataTable/utils/isEntityClean.d.ts

@@ -1 +1,3 @@
-export function isEntityClean(e: any): boolean;
+export declare function isEntityClean(e: {
+    [key: string]: unknown;
+} | null): boolean;

package/DataTable/utils/primarySelectedValue.d.ts

@@ -1 +1 @@
-export const PRIMARY_SELECTED_VAL: "main_cell";
+export declare const PRIMARY_SELECTED_VAL = "main_cell";

package/DataTable/utils/removeCleanRows.d.ts

@@ -1,4 +1,12 @@
-export function removeCleanRows(entities: any, cellValidation: any): {
-    entsToUse: any;
-    validationToUse: {};
+export declare const removeCleanRows: (entities: ({
+    [key: string]: unknown;
+} & {
+    _isClean?: boolean;
+})[], cellValidation: Record<string, unknown>) => {
+    entsToUse: ({
+        [key: string]: unknown;
+    } & {
+        _isClean?: boolean;
+    })[];
+    validationToUse: Record<string, unknown>;
 };

package/DataTable/utils/selection.d.ts

@@ -1 +1,3 @@
-export function getSelectedRowsFromEntities(entities: any, idMap: any): any;
+export declare const getSelectedRowsFromEntities: (entities: {
+    [key: string]: unknown;
+}[], idMap: Record<string, boolean>) => number[];

package/DataTable/utils/types/Entity.d.ts

@@ -0,0 +1,5 @@
+export type Entity = {
+    id?: string | number;
+} | {
+    code?: string;
+};

package/DataTable/utils/types/Field.d.ts

@@ -0,0 +1,4 @@
+export type Field = {
+    path: string;
+    type: "genericSelect" | string;
+};

package/DataTable/utils/types/OrderBy.d.ts

@@ -0,0 +1,11 @@
+type OrderByClause<T = {
+    id: string;
+}> = {
+    path?: string;
+    direction?: "asc" | "desc";
+    type?: string;
+    sortFn?: ((record: T) => unknown) | string | Array<((record: T) => unknown) | string>;
+    getValueToFilterOn?: (record: T) => unknown;
+};
+export type OrderBy = OrderByClause | OrderByClause[] | Record<string, "asc" | "desc">;
+export {};

package/DataTable/utils/types/Schema.d.ts

@@ -0,0 +1,4 @@
+import { Field } from './Field';
+export type Schema = {
+    fields: Field[];
+};

package/DataTable/utils/useDeepEqualMemo.d.ts

@@ -0,0 +1 @@
+export function useDeepEqualMemo(value: any): undefined;

package/DataTable/utils/useTableEntities.d.ts

@@ -1,5 +1,18 @@
-export function useTableEntities(tableFormName: any): {
-    selectTableEntities: (entities?: any[]) => void;
-    allOrderedEntities: any;
-    selectedEntities: any;
+type _Entity = {
+    [key: string]: unknown;
+} & {
+    id: string;
 };
+type SelectedEntityIdMap<Entity extends _Entity> = Record<string, {
+    entity: Entity;
+    time: number;
+    index?: number;
+}>;
+export declare const useTableEntities: <Entity extends _Entity>(tableFormName: string) => {
+    selectTableEntities: (entities?: {
+        id: string;
+    }[]) => void;
+    allOrderedEntities: Entity[] | undefined;
+    selectedEntities: SelectedEntityIdMap<Entity> | undefined;
+};
+export {};

package/DataTable/utils/useTableParams.d.ts

@@ -0,0 +1,49 @@
+/**
+ *  Note all these options can be passed at Design Time or at Runtime (like reduxForm())
+ *
+ * @export
+ *
+ * @param {compOrOpts} compOrOpts
+ * @typedef {object} compOrOpts
+ * @property {*string} formName - required unique identifier for the table
+ * @property {Object | Function} schema - The data table schema or a function returning it. The function wll be called with props as the argument.
+ * @property {boolean} urlConnected - whether the table should connect to/update the URL
+ * @property {boolean} withSelectedEntities - whether or not to pass the selected entities
+ * @property {boolean} isCodeModel - whether the model is keyed by code instead of id in the db
+ * @property {object} defaults - tableParam defaults such as pageSize, filter, etc
+ * @property {boolean} noOrderError - won't console an error if an order is not found on schema
+ */
+export default function useTableParams(props: any): any;
+/**
+ * Note all these options can be passed at Design Time or at Runtime (like reduxForm())
+ */
+export type compOrOpts = {
+    /**
+     * } formName - required unique identifier for the table
+     */
+    string: any;
+    /**
+     * - The data table schema or a function returning it. The function wll be called with props as the argument.
+     */
+    schema: Object | Function;
+    /**
+     * - whether the table should connect to/update the URL
+     */
+    urlConnected: boolean;
+    /**
+     * - whether or not to pass the selected entities
+     */
+    withSelectedEntities: boolean;
+    /**
+     * - whether the model is keyed by code instead of id in the db
+     */
+    isCodeModel: boolean;
+    /**
+     * - tableParam defaults such as pageSize, filter, etc
+     */
+    defaults: object;
+    /**
+     * - won't console an error if an order is not found on schema
+     */
+    noOrderError: boolean;
+};

package/DataTable/utils/utils.d.ts

@@ -1,5 +1,16 @@
-export function getFieldPathToIndex(schema: any): {};
-export function defaultParsePaste(str: any): any;
-export function getEntityIdToEntity(entities: any): {};
-export function getNumberStrAtEnd(str: any): any;
-export function stripNumberAtEnd(str: any): any;
+import { Entity } from './types/Entity';
+import { Field } from './types/Field';
+export declare const getFieldPathToIndex: (schema: {
+    fields: Field[];
+}) => {
+    [path: string]: number;
+};
+export declare const defaultParsePaste: (str: string) => string[][];
+export declare const getEntityIdToEntity: (entities: Entity[]) => {
+    [id: string]: {
+        e: Entity;
+        i: number;
+    };
+};
+export declare const getNumberStrAtEnd: (str: string) => string | null | undefined;
+export declare const stripNumberAtEnd: (str: string) => string;