@acuteinfo/common-base 1.0.0

package/dist/packages/form/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./src/atoms";
+export * from "./src/field";
+export * from "./src/form";
+export * from "./src/util";
+export * from "./src/fieldArray";
+export * from "./src/types";
+export * from "./src/context";
+export * from "./src/observer";

package/dist/packages/form/src/atoms.d.ts

@@ -0,0 +1,36 @@
+import { FormAtomType, FormFieldAtomType, FormArrayFieldRowsAtomType, FormFieldRegisterSelectorAttributes, FormFieldRegistryAtomType, DependentValuesType, SubscritionFieldsType } from "./types";
+export declare const atomKeys: {
+    formAtom: string;
+    formFieldAtom: string;
+    formArrayFieldRowsAtom: string;
+    formArrayFieldRegistryAtom: string;
+    formFieldRegistryAtom: string;
+    formFieldRegisterSelector: string;
+    formFieldUnregisterSelector: string;
+    formArrayFieldRegisterSelector: string;
+    formArrayFieldUnregisterSelector: string;
+    subscribeToFormFieldsSelector: string;
+    isFormArrayFieldRegistered: string;
+    formFieldsExcludedAtom: string;
+    formFieldExcludeAddSelector: string;
+    formFieldExcludeRemoveSelector: string;
+    formFieldsErrorWatcherAtom: string;
+    formFieldsErrorWatcherAddSelector: string;
+    formFieldsErrorWatcherRemoveSelector: string;
+};
+export declare const formAtom: (param: string) => import("recoil").RecoilState<FormAtomType>;
+export declare const formFieldAtom: (param: string) => import("recoil").RecoilState<FormFieldAtomType>;
+export declare const formFieldsErrorWatcherAtom: (param: string) => import("recoil").RecoilState<string[]>;
+export declare const formFieldsErrorWatcherAddSelector: (param: string) => import("recoil").RecoilState<string>;
+export declare const formFieldsErrorWatcherRemoveSelector: (param: string) => import("recoil").RecoilState<string>;
+export declare const formFieldsExcludedAtom: (param: string) => import("recoil").RecoilState<string[]>;
+export declare const formFieldExcludeAddSelector: (param: string) => import("recoil").RecoilState<string>;
+export declare const formFieldExcludeRemoveSelector: (param: string) => import("recoil").RecoilState<string>;
+export declare const formFieldRegistryAtom: (param: string) => import("recoil").RecoilState<FormFieldRegistryAtomType>;
+export declare const formFieldRegisterSelector: (param: string) => import("recoil").RecoilState<FormFieldRegisterSelectorAttributes>;
+export declare const formFieldUnregisterSelector: (param: string) => import("recoil").RecoilState<string>;
+export declare const formArrayFieldRowsAtom: (param: string) => import("recoil").RecoilState<FormArrayFieldRowsAtomType>;
+export declare const formArrayFieldRegistryAtom: (param: string) => import("recoil").RecoilState<string[]>;
+export declare const formArrayFieldRegisterSelector: (param: string) => import("recoil").RecoilState<string>;
+export declare const formArrayFieldUnregisterSelector: (param: string) => import("recoil").RecoilState<string>;
+export declare const subscribeToFormFieldsSelector: (param: SubscritionFieldsType) => import("recoil").RecoilValueReadOnly<DependentValuesType>;

package/dist/packages/form/src/context.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { FormContextType } from "./types";
+export declare const FormContext: import("react").Context<FormContextType>;

package/dist/packages/form/src/field.d.ts

@@ -0,0 +1,33 @@
+import { UseFieldHookProps, ValidateFnType, DependentValuesType } from "./types";
+export declare const useField: ({ fieldKey, name, dependentFields, validate, validationRun, shouldExclude, isReadOnly, postValidationSetCrossFieldValues, runPostValidationHookAlways, runValidationOnDependentFieldsChange, skipValueUpdateFromCrossFieldWhenReadOnly, runExternalFunction, onFormDataChange, }: UseFieldHookProps) => {
+    formState: any;
+    whenToRunValidation: ("onChange" | "onBlur" | "all") | undefined;
+    isSubmitting: boolean;
+    handleChange: (eventOrTextValue: React.ChangeEvent<any> | Date | string | number | boolean | any[], displayValue?: Date | string | number | boolean | any[]) => void;
+    handleBlur: () => Promise<void>;
+    setTouched: () => void;
+    setValue: (val: any, displayValue: any, alwaysRun?: boolean) => void;
+    setValueAsCB: (val: any) => void;
+    setErrorAsCB: (val: any) => void;
+    setIncomingMessage: (value: any) => void;
+    runValidation: (mergeObj: any, alwaysRun?: boolean, touchAndValidate?: boolean) => void;
+    dependentValues: DependentValuesType;
+    handleOptionValueExtraData: (data: any) => void;
+    setDisplayValue: (displayValue: any) => void;
+    error: string;
+    fieldKey: string;
+    name: string;
+    value: any;
+    displayValue: any;
+    touched: boolean;
+    validationRunning: boolean;
+    excluded: boolean;
+    readOnly: boolean;
+    validate?: typeof ValidateFnType | import("./types").EmptyFnType | null | undefined;
+    incomingMessage?: any;
+    dependentFields?: string | string[] | undefined;
+    validationAPIResult?: any;
+    skipValueUpdateFromCrossFieldWhenReadOnly: boolean;
+    optionData?: any;
+};
+export declare const transformDependentFieldsState: (dependentValues: DependentValuesType) => {};

package/dist/packages/form/src/fieldArray.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { UseFieldArrayHookProps, RenderFn } from "./types";
+export declare const useFieldArray: ({ arrayFieldName, template, shouldExclude, dependentFields, getFixedRowsCount, }: UseFieldArrayHookProps) => {
+    fieldRows: import("./types").FormArrayFieldRowsAtomType;
+    templateFieldNames: string[];
+    clearFieldArray: () => void;
+    getAllRowsValues: () => any;
+    unshift: () => void;
+    push: () => void;
+    insert: (index: number) => void;
+    pop: () => void;
+    remove: (index: number) => void;
+    swap: (indexA: number, indexB: number) => void;
+    move: (from: number, to: number) => void;
+    renderRows: (renderFn: RenderFn) => JSX.Element[];
+    excluded: boolean;
+    isSubmitting: boolean;
+    formState: any;
+    formName: string;
+};

package/dist/packages/form/src/form.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { UseFormHookProps } from "./types";
+export declare const useForm: ({ onSubmit, readOnly }: UseFormHookProps) => {
+    submitAttempt: number;
+    isSubmitting: boolean;
+    submitSuccessful: boolean;
+    serverSentError: string;
+    serverSentErrorDetail: string;
+    handleSubmit: (e: import("react").FormEvent<any>, actionFlag?: String | undefined, isValidate?: boolean | undefined) => void;
+    handleSubmitPartial: (fields: string[]) => Promise<boolean>;
+    handleReset: (e: React.FormEvent<any>) => void;
+    handleResetPartial: (fields: string[]) => void;
+    handleClear: (e: any) => void;
+    handleClearPartial: (fields: string[]) => void;
+    getFieldData: () => Promise<{}>;
+};

package/dist/packages/form/src/observer.d.ts

@@ -0,0 +1 @@
+export declare const TimeTravelObserver: () => import("react/jsx-runtime").JSX.Element;

package/dist/packages/form/src/types.d.ts

@@ -0,0 +1,120 @@
+/// <reference types="react" />
+import { AnyObjectSchema } from "yup";
+export interface TemplateFieldRowType {
+    fieldIndexKey: string;
+    cells: TemplateFieldCellsObjectType;
+}
+export interface TemplateFieldCellsObjectType {
+    [key: string]: TemplateFieldCellType;
+}
+export interface TemplateFieldCellType {
+    name: string;
+    key: string;
+}
+type ValidationRunType = "onChange" | "onBlur" | "all";
+export interface FormContextType {
+    formName: string;
+    validationRun?: ValidationRunType;
+    resetFieldOnUnmount?: boolean;
+    initialValues?: InitialValuesType;
+    validationSchema?: AnyObjectSchema;
+    formState: any;
+    defaultArrayFieldValues?: InitialValuesType;
+}
+export type FormFieldRegistryAtomType = string[];
+export interface FormFieldRegisterSelectorAttributes {
+    fieldName: string;
+    defaultValue: any;
+}
+export interface InitialValuesType {
+    [key: string]: any;
+}
+export interface FormAtomType {
+    submitAttempt: number;
+    isSubmitting: boolean;
+    submitSuccessful: boolean;
+    serverSentError: string;
+    serverSentErrorDetail: string;
+}
+export interface FormFieldAtomType {
+    fieldKey: string;
+    name: string;
+    value: any;
+    displayValue: any;
+    touched: boolean;
+    error: string | null;
+    validationRunning: boolean;
+    excluded: boolean;
+    readOnly: boolean;
+    validate?: null | typeof ValidateFnType | EmptyFnType;
+    incomingMessage?: any;
+    dependentFields?: string[] | string;
+    validationAPIResult?: any;
+    skipValueUpdateFromCrossFieldWhenReadOnly: boolean;
+    optionData?: any;
+}
+export interface DependentValuesType {
+    [key: string]: FormFieldAtomType;
+}
+export interface FormArrayFieldRowsAtomType {
+    fieldName: string;
+    templateFieldRows: TemplateFieldRowType[];
+    lastInsertIndex: number;
+    resetFlag: boolean;
+    excluded: boolean;
+}
+export interface UseFormHookProps {
+    onSubmit: SubmitFnType;
+    readOnly?: boolean;
+}
+export interface UseFieldHookProps {
+    fieldKey: string;
+    name: string;
+    validate?: typeof ValidateFnType;
+    validationRun?: ValidationRunType;
+    dependentFields?: string[] | string;
+    _dependentFields?: string[] | string;
+    shouldExclude?: typeof shouldExcludeFnType;
+    isReadOnly?: typeof shouldExcludeFnType;
+    postValidationSetCrossFieldValues?: typeof PostValidationSetCrossFieldValuesFnType;
+    runPostValidationHookAlways?: boolean;
+    runValidationOnDependentFieldsChange?: boolean;
+    skipValueUpdateFromCrossFieldWhenReadOnly?: boolean;
+    runExternalFunction?: boolean;
+    onFormDataChange?: any;
+    __EDIT__?: any;
+    __VIEW__?: any;
+}
+export interface UseFieldArrayHookProps {
+    arrayFieldName: string;
+    template: any;
+    dependentFields?: string[] | string;
+    shouldExclude?: typeof shouldExcludeFnType;
+    getFixedRowsCount?: typeof getFixedRowsCountFnType;
+}
+export interface SubscritionFieldsType {
+    [key: string]: string[] | string | undefined;
+}
+export declare function getFixedRowsCountFnType(fieldData: FormArrayFieldRowsAtomType, dependentFieldsValues: DependentValuesType, formState: any): number;
+export declare function shouldExcludeFnType(fieldData: FormFieldAtomType, dependentFieldsValues: DependentValuesType, formState: any): Promise<boolean> | boolean;
+export declare function SchemaValidateFnType(fieldData: FormFieldAtomType, formState: any): Promise<any> | any;
+export declare function ValidateFnType(fieldData: FormFieldAtomType, dependentFieldsValues: DependentValuesType, formState: any): Promise<any> | any;
+export declare function PostValidationSetCrossFieldValuesFnType(fieldData: FormFieldAtomType, formState: any, dependentFieldsState: any): Promise<InitialValuesType | undefined | null> | InitialValuesType | undefined | null;
+export interface EmptyFnType {
+    (args: FormFieldAtomType): string;
+}
+export interface SubmitFnType {
+    (values: Object, displayValues: Object, endSubmit: (submitSuccessful: boolean, message?: string) => void, setFieldErrors: (fieldsErrorObj: FieldsErrorObjType) => void, actionFlag?: String): void;
+}
+export interface RenderFnOptionsType {
+    row: TemplateFieldRowType;
+    fields: string[];
+    rowIndex: number;
+    removeFn: (index: number) => void;
+    totalRows: number;
+}
+export type RenderFn = (options: RenderFnOptionsType) => JSX.Element;
+export interface FieldsErrorObjType {
+    [key: string]: string | null;
+}
+export {};

package/dist/packages/form/src/util.d.ts

@@ -0,0 +1,9 @@
+import * as yup from "yup";
+import { FormFieldAtomType } from "./types";
+export declare const isString: (obj: any) => obj is string;
+export declare const isObject: (obj: any) => obj is Object;
+export declare const isInteger: (obj: any) => boolean;
+export declare function getIn(obj: any, key: string | string[], def?: any, p?: number): any;
+export declare function setIn(obj: any, path: string, value: any): any;
+export declare const yupValidationHelper: (schema: yup.AnyObjectSchema | yup.StringSchema<any> | yup.NumberSchema<any>) => (field: FormFieldAtomType) => Promise<any>;
+export declare const yupReachAndValidate: (schema: yup.AnyObjectSchema | undefined, path: string) => ((field: FormFieldAtomType) => Promise<any>) | undefined;

package/dist/pages_audit/auth/authContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { AuthContextType } from "components/types";
+export declare const AuthContext: import("react").Context<AuthContextType>;
+export declare const AuthProvider: ({ children }: {
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/pages_audit/common/crud2/context.d.ts

@@ -0,0 +1,20 @@
+import { FC, ReactNode } from "react";
+interface CRUDProviderType {
+    context: any;
+    insertFormData: CRUDFNType;
+    checkFormDataExist: CRUDFNType;
+    deleteFormData: CRUDFNType;
+    updateFormData: CRUDFNType;
+    getFormMetaData: CRUDFNType;
+    getFormData: CRUDFNType;
+    getGridFormMetaData: CRUDFNType;
+    getGridFormData: CRUDFNType;
+    children?: ReactNode;
+}
+export declare const CRUDContext: import("react").Context<CRUDProviderType>;
+interface CRUDFNType {
+    fn: any;
+    args: any;
+}
+export declare const CRUDContextProvider: FC<CRUDProviderType>;
+export {};

package/dist/pages_audit/common/crud2/delete.d.ts

@@ -0,0 +1,5 @@
+export declare const DeleteAction: ({ isDataChangedRef, closeDialog, serialNo }: {
+    isDataChangedRef: any;
+    closeDialog: any;
+    serialNo: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/pages_audit/common/crud2/formNew.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+export declare const FormNew: FC<{
+    isDataChangedRef: any;
+    successAction: any;
+    cancelAction: any;
+    formStyle?: any;
+}>;

package/dist/pages_audit/common/crud2/formNewExistIfNotCreate.d.ts

@@ -0,0 +1,14 @@
+export declare const FormNewExistsIfNotCreate: ({ isDataChangedRef, successAction, readOnly, closeDialog, formStyle, }: {
+    isDataChangedRef: any;
+    successAction: any;
+    readOnly: any;
+    closeDialog: any;
+    formStyle: any;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export declare const CreateFormConfirmation: ({ successAction, isDataChangedRef, readOnly, closeDialog, formStyle, }: {
+    successAction: any;
+    isDataChangedRef: any;
+    readOnly: any;
+    closeDialog: any;
+    formStyle: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/pages_audit/common/crud2/formViewEdit.d.ts

@@ -0,0 +1,11 @@
+import { FC } from "react";
+export declare const FormViewEdit: FC<{
+    isDataChangedRef: any;
+    closeDialog?: any;
+    defaultView?: "view" | "edit";
+    serialNo?: string;
+    setEditFormStateFromInitValues?: any;
+    readOnly?: boolean;
+    disableCache?: boolean;
+    formStyle?: any;
+}>;

package/dist/pages_audit/common/crud2/gridCRUD.d.ts

@@ -0,0 +1,16 @@
+import { FC } from "react";
+import { DialogProps } from "@mui/material/Dialog";
+export declare const GridCRUD: FC<{
+    isDataChangedRef: any;
+    showDocuments?: boolean;
+    disableActions?: string | string[];
+    setEditFormStateFromInitValues?: any;
+    secondaryProduct?: string;
+    secondaryProductDataExist?: boolean;
+    secondaryProductDisableCache?: boolean;
+    maxWidth?: DialogProps["maxWidth"];
+    dialogAlignTop?: boolean;
+    formStyle?: any;
+    readOnly?: any;
+    detailsContextGenerator: Function;
+}>;

package/dist/pages_audit/common/crud2/gridWrapper.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ActionTypes } from "components/dataTable";
+type GridWrapperType = {
+    actions: ActionTypes[];
+    setAction: any;
+};
+export declare const MyGridWrapper: import("react").ForwardRefExoticComponent<GridWrapperType & import("react").RefAttributes<any>>;
+export {};

package/dist/pages_audit/common/crud2/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./gridCRUD";
+export * from "./simpleCRUD";
+export * from "./context";

package/dist/pages_audit/common/crud2/simpleCRUD.d.ts

@@ -0,0 +1,9 @@
+import { FC } from "react";
+export declare const SimpleCRUD: FC<{
+    isDataChangedRef: any;
+    dataAlwaysExists: any;
+    closeDialog?: any;
+    readOnly?: boolean;
+    disableCache?: boolean;
+    formStyle?: any;
+}>;

package/dist/pages_audit/common/dialogStyles.d.ts

@@ -0,0 +1 @@
+export declare const useDialogStyles: (props?: any) => import("@mui/styles").ClassNameMap<"topScrollPaper" | "topPaperScrollBody">;