@apia/api 3.0.9 → 3.0.11

package/dist/index.d.ts

@@ -1,11 +1,14 @@
-import * as React from 'react';
+import * as React$1 from 'react';
 import React__default from 'react';
 import { AxiosResponse, AxiosRequestConfig } from 'axios';
-import { TApiaFilter, TModify, TApiaLoad, TApiaFormElement } from '@apia/util';
+import * as _apia_util from '@apia/util';
+import { TApiaFilter, TModify, TApiaLoad, TApiaFormElement, TApiaFilterOption, TApiaFunction, TApiaFunctionPageInfo } from '@apia/util';
 import { TNotificationMessage, notify } from '@apia/notifications';
-import { TModal } from '@apia/components';
+import { TModal, TOpenModal, ApiaUtilModalHandler } from '@apia/components';
 import QueryString from 'qs';
-import { TResponsiveTableColumn } from '@apia/table';
+import { TResponsiveTableColumn, TResponsiveTableContextProps, TResponsiveTableRow, TResponsiveTableRowsSelectionEvent, TResponsiveTableSortChangeEvent } from '@apia/table';
+import * as lodash from 'lodash';
+import * as theme_ui from 'theme-ui';
 
 declare function getConfig<LoadType>(outerBehaveConfig?: IApiaApiRequestConfig<LoadType>): IApiaApiRequestConfig<unknown> & IApiaApiRequestConfig<LoadType> & Partial<IApiaApiRequestConfig<unknown>>;
 type TApiaApiAxiosResponse<LoadType> = AxiosResponse<LoadType | null> & {
@@ -245,14 +248,14 @@ type TApiaApiMethodHandler = {
     reset: () => void;
     setError: typeof notify;
     setMessage: (message: Record<string, unknown>) => unknown;
-    setState: React.Dispatch<React.SetStateAction<IApiaApiHandlerState>>;
+    setState: React$1.Dispatch<React$1.SetStateAction<IApiaApiHandlerState>>;
     state: IApiaApiHandlerState;
     setValue: (name: string, value: string) => void;
 };
 type TApiaApiMethod = (handler: TApiaApiMethodHandler, props: TMethod['props']) => Promise<void> | void;
 type TApiaApiField = TApiaApiMethodHandler & {
     element: TModify<TApiaFormElement, {
-        onChange: React.ChangeEventHandler;
+        onChange: React$1.ChangeEventHandler;
     }>;
 };
 type TStoredApiaApiMethod = (props?: TMethod['props']) => unknown;
@@ -277,7 +280,7 @@ interface IApiaApiHandlerState {
     errors: Record<string, string>;
     windowIndex: number;
 }
-declare const ApiaApiHandler: React.MemoExoticComponent<() => React.JSX.Element>;
+declare const ApiaApiHandler: React$1.MemoExoticComponent<() => React$1.JSX.Element>;
 
 declare global {
     interface Window {
@@ -294,5 +297,129 @@ declare global {
  * */
 declare const getModal: (path: string) => React__default.LazyExoticComponent<React__default.ComponentType<TApiaApiField>>;
 
-export { ApiaApi, ApiaApiHandler, type IApiaApiRequestConfig, type TApiaApiAxiosResponse, type TApiaApiMethod, type TApiaApiResult, getFunction, getModal, makeApiaUrl };
+type TFilter = {
+    avoidLabel?: boolean;
+    column?: string;
+    errorMessage?: string;
+    id: string;
+    isAdditional?: boolean;
+    isHidden?: boolean;
+    onChange?: (queryController: QueryController) => unknown;
+    options?: TApiaFilterOption[];
+    placeholder?: string;
+    readonly?: boolean;
+    required?: boolean;
+    runAutomatically?: boolean;
+    title?: string;
+    tooltip?: string;
+    type?: 'date' | 'D' | 'S' | 'number' | 'N' | 'apiaNumber' | 'triple' | 'dateHour';
+    value: any;
+};
+
+type FilterState = TFilter;
+declare class Filter {
+    filterState: FilterState;
+    constructor(properties: TFilter);
+    Component: (({ filter }: {
+        filter: TApiaFilter;
+    }) => React$1.JSX.Element) & {
+        displayName: string;
+    };
+}
+
+type TableControllerState = {
+    columns: Map<string, TResponsiveTableColumn>;
+    filters: Map<string | number, Filter>;
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        totalRecords: number;
+    };
+    props: Omit<TResponsiveTableContextProps, 'FiltersRenderer' | 'SelectionHandler' | 'filters' | 'columns' | 'rows' | keyof TableControllerEvents>;
+    rows: TResponsiveTableRow[];
+};
+type TableControllerEvents = {
+    onChangeSelection: TResponsiveTableRowsSelectionEvent;
+    onFilterBlur: TApiaFilter;
+    onFilterChange: TApiaFilter;
+    onFilterPressEnter: TApiaFilter;
+    onPage: number;
+    onRefresh: null;
+    onRowClick: TResponsiveTableRowsSelectionEvent[number];
+    onSelectRows: TResponsiveTableRowsSelectionEvent;
+    onSortChange: TResponsiveTableSortChangeEvent;
+};
+
+declare class TableController {
+    private emitter;
+    private tableName;
+    private tableSelectionController;
+    private controllerComponent;
+    state: TableControllerState;
+    constructor(initialState?: Partial<TableControllerState>);
+    Context: (({ children }: {
+        children: React.ReactNode;
+    }) => React$1.JSX.Element) & {
+        displayName: string;
+    };
+    getTableName(): string;
+    Pagination: (() => React$1.JSX.Element) & {
+        displayName: string;
+    };
+    Table: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<theme_ui.BoxProps & React$1.RefAttributes<HTMLDivElement>>>;
+    on<K extends keyof TableControllerEvents>(ev: K, cb: (e: TableControllerEvents[K]) => unknown): _apia_util.UnSubscriber;
+    updateState(newState: Partial<TableControllerState> | ((currentState: TableControllerState) => void)): void;
+}
+
+type QueryControllerStructure = {
+    columns: TResponsiveTableColumn[];
+    description: string;
+    filters: TFilter[];
+    hasAdditionalInformation: boolean;
+    isDynamic: boolean;
+    openFiltersAutomatically: boolean;
+    runFiltersAutomatically: boolean;
+    title: string;
+};
+declare abstract class QueryController {
+    ajaxUrl: string;
+    private hasInited;
+    private initializing;
+    structure: QueryControllerStructure | null;
+    tableController: TableController;
+    constructor(ajaxUrl: string);
+    private initEvents;
+    protected getLoadStructureParameters(): Record<string, unknown>;
+    protected getPageParameters(): Record<string, unknown>;
+    protected getRefreshParameters(): Record<string, unknown>;
+    protected getSortParameters(): Record<string, unknown>;
+    protected parseLoadStructureResponse(response: Record<string, unknown>): QueryControllerStructure;
+    protected parseRefreshResponse(response?: TApiaFunction | null): void;
+    protected getStructure(): Promise<QueryControllerStructure>;
+    protected parseStructure(structure: QueryControllerStructure): void;
+    protected updatePageState(pageInfo?: TApiaFunctionPageInfo): void;
+    protected updateRows(rows: TResponsiveTableRow[]): void;
+    initialLoad(): Promise<void>;
+    page(num: number): Promise<void>;
+    protected executeRefresh: lodash.DebouncedFunc<() => Promise<void>>;
+    refresh(): Promise<void | undefined>;
+    sort(column: string): Promise<void>;
+}
+
+type QueryModalControllerEvents = Pick<TableControllerEvents, 'onSelectRows'>;
+declare class QueryModalController {
+    private emitter;
+    protected queryController: QueryController;
+    private modalHandler;
+    private currentSelection;
+    private additionalFiltersController;
+    constructor(queryController: QueryController);
+    protected getModalDefinition(): TOpenModal;
+    getQueryController(): QueryController;
+    on<K extends keyof QueryModalControllerEvents>(ev: K, cb: (e: QueryModalControllerEvents[K]) => unknown): _apia_util.UnSubscriber;
+    openModal: (properties?: TOpenModal) => Promise<void>;
+    getModalHandler(): ApiaUtilModalHandler | null;
+}
+
+export { ApiaApi, ApiaApiHandler, type IApiaApiRequestConfig, QueryController, type QueryControllerStructure, QueryModalController, type TApiaApiAxiosResponse, type TApiaApiMethod, type TApiaApiResult, type TFilter, getFunction, getModal, makeApiaUrl };
 //# sourceMappingURL=index.d.ts.map