@axinom/mosaic-ui 0.39.1-feat-gs.2 → 0.40.0-rc.0

package/src/components/FormStation/FormStation.tsx

@@ -1,23 +1,51 @@
 import clsx from 'clsx';
-import { Formik, FormikValues } from 'formik';
-import React, { PropsWithChildren } from 'react';
+import {
+  Form,
+  Formik,
+  FormikHelpers,
+  FormikValues,
+  useFormikContext,
+} from 'formik';
+import React, {
+  PropsWithChildren,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+import { useHistory } from 'react-router-dom';
 import { OptionalObjectSchema } from 'yup/lib/object';
-import type { Data } from '../../types/data';
-import type { StationMessage } from '../models';
-import { FormContentWrapper } from './FormContentWrapper/FormContentWrapper';
-import type {
-  FormActionData,
-  InitialFormData,
-  ObjectSchemaDefinition,
-  SaveDataFunction,
-} from './FormStation.models';
+import { SaveIndicatorType, setSaveIndicator } from '../../initialize';
+import { Data } from '../../types/data';
+import { ErrorTypeToStationError } from '../../utils/ErrorTypeToStationError';
+import { Actions, ActionsProps } from '../Actions';
+import { isNavigationAction } from '../Actions/Action/Action';
+import { IconName } from '../Icons';
+import { MessageBar } from '../MessageBar';
+import {
+  PageHeader,
+  PageHeaderActionType,
+  PageHeaderProps,
+} from '../PageHeader';
+import { ErrorType, StationMessage } from '../models';
+import { FormActionData, InitialFormData } from './FormStation.models';
 import classes from './FormStation.scss';
-import { FormStationActions } from './FormStationActions/FormStationActions';
-import { FormStationContextProvider } from './FormStationContext/FormStationContextProvider';
-import { FormStationHeader } from './FormStationHeader/FormStationHeader';
 import { SaveOnNavigate } from './SaveOnNavigate/SaveOnNavigate';
-import { useDataProvider } from './helpers/useDataProvider';
-import { useValidationError } from './helpers/useValidationError';
+import { StationErrorStateType } from './StationErrorStateType';
+import { useValidationError } from './useValidationError';
+
+export type ObjectSchemaDefinition<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  T extends Data | null = any,
+> = {
+  // TODO: Adding 'any' here since there are a couple of open issues regarding generics in the latest version of yup.
+  // https://github.com/jquense/yup/issues/1159
+  // https://github.com/jquense/yup/issues/1247
+  // Consider revisiting once 'yup' has addressed these issues.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [field in keyof T]: any;
+};
 
 export interface FormStationProps<
   TValues extends Data = FormikValues,
@@ -61,11 +89,28 @@ export interface FormStationProps<
    * Called whenever the form needs to be saved.
    * This method needs to throw an exception in case the saving did not succeed.
    */
-  saveData: SaveDataFunction<TValues, TSubmitResponse>;
+  saveData: (
+    /** The current values of the form */
+    values: TValues,
+    /** The initial values of the form */
+    initialData: InitialFormData<TValues>,
+    /** The Formik state helpers */
+    formikHelpers: FormikHelpers<TValues>,
+  ) => Promise<TSubmitResponse> | void;
   /** CSS Class name for additional styles */
   className?: string;
-  /** Periodically calls saveData when the form values change */
-  autosave?: boolean;
+}
+
+interface FormActionProps<T, Y> extends Omit<ActionsProps, 'actions'> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  validationSchema?: OptionalObjectSchema<ObjectSchemaDefinition<any>>;
+  actions?: FormActionData<T, Y>[];
+  setStationError: (error: StationErrorStateType) => void;
+  setValidationError: () => void;
+  submitResponse?: React.MutableRefObject<Y | undefined>;
+  alwaysSubmitBeforeAction?: boolean;
+  className?: string;
+  isFormSubmitting?: boolean;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -86,30 +131,141 @@ export const FormStation = <TValues extends Data, TSubmitResponse = unknown>({
   alwaysSubmitBeforeAction = false,
   stationMessage,
   className = '',
-  autosave = false,
 }: PropsWithChildren<
   FormStationProps<TValues, TSubmitResponse>
 >): JSX.Element => {
-  const currentValuesRef = React.useRef<TValues>({} as TValues);
+  const [stationError, setStationError] = useState<StationErrorStateType>();
 
-  const {
-    onSubmit,
+  const { setValidationError, validationWatcher } = useValidationError(
     stationError,
     setStationError,
-    isFormSubmitting,
-    lastSubmittedResponse,
-    initialValues,
-  } = useDataProvider<TValues, TSubmitResponse>(
-    initialData,
-    saveData,
-    currentValuesRef,
   );
 
-  const { setValidationError, validationWatcher } = useValidationError(
-    stationError,
-    setStationError,
+  const submitResponse = useRef<TSubmitResponse>();
+  const [isFormSubmitting, setIsFormSubmitting] = useState<boolean>(false);
+
+  const onSubmit = useCallback(
+    async (
+      values: TValues,
+      formikHelpers: FormikHelpers<TValues>,
+    ): Promise<void> => {
+      if (isFormSubmitting) {
+        return;
+      }
+
+      try {
+        setIsFormSubmitting(true);
+        setSaveIndicator(SaveIndicatorType.Saving);
+        setStationError(undefined);
+        if (!initialData.loading && saveData) {
+          const response = await saveData(values, initialData, formikHelpers);
+          if (response) {
+            submitResponse.current = response;
+          }
+        }
+      } catch (error) {
+        setStationError(
+          ErrorTypeToStationError(
+            error as ErrorType,
+            'An error occurred when trying to save data.',
+          ),
+        );
+
+        setSaveIndicator(SaveIndicatorType.Dirty);
+
+        // We still throw the error, to make sure that navigation or action execution
+        // will not continue after a failed save.
+        throw error;
+      } finally {
+        formikHelpers.setSubmitting(false);
+        setIsFormSubmitting(false);
+      }
+    },
+    [isFormSubmitting, initialData, saveData, setStationError],
   );
 
+  useEffect(() => {
+    if (
+      initialData.error ||
+      (initialData.data === null && !initialData.loading) ||
+      initialData.entityNotFound
+    ) {
+      const stationError = {
+        ...ErrorTypeToStationError(
+          initialData.error,
+          'An error occurred when trying to load data.',
+          'Entity not found',
+        ),
+        type: 'loading',
+      };
+
+      setStationError(stationError);
+    } else {
+      if (stationError?.type === 'loading') {
+        // Only clear the error if it is a loading error, which now seems to be cleared.
+        setStationError(undefined);
+      }
+    }
+  }, [
+    initialData.loading,
+    initialData.error,
+    initialData.entityNotFound,
+    initialData.data,
+    stationError?.type,
+  ]);
+
+  const getContent = (): JSX.Element | undefined => {
+    if (initialData.loading) {
+      // TODO: Loading skeleton of the page
+      return;
+    }
+
+    if (
+      initialData.error ||
+      initialData.data === null ||
+      initialData.entityNotFound
+    ) {
+      // Error on loading - we can't show the form
+      return <div className={classes.loadingError}></div>;
+    }
+
+    // Loading successful
+    return (
+      <>
+        <SaveOnNavigate
+          isSubmitting={isFormSubmitting}
+          onNavigationCancelled={setValidationError}
+        />
+        <div className={classes.main}>
+          <div
+            className={clsx(classes.formWrapper, {
+              [classes.hasMessage]: stationMessage,
+            })}
+          >
+            {stationMessage && (
+              <MessageBar {...stationMessage}>{stationMessage.body}</MessageBar>
+            )}
+            <div
+              className={clsx(classes.formContainer, {
+                [classes.paddedContent]: !edgeToEdgeContent,
+              })}
+            >
+              <Form>
+                <>
+                  {children}
+                  {/* Adding a invisible text input here to prevent the browser from submitting on "Enter" when there is only a single text input field in the form
+                  See: https://www.w3.org/MarkUp/html-spec/html-spec_8.html#SEC8.2 */}
+                  <input type="text" style={{ display: 'none' }} />
+                </>
+              </Form>
+            </div>
+          </div>
+          {infoPanel}
+        </div>
+      </>
+    );
+  };
+
   return (
     <div
       className={clsx(
@@ -122,50 +278,229 @@ export const FormStation = <TValues extends Data, TSubmitResponse = unknown>({
       )}
     >
       <Formik
-        initialValues={initialValues ?? ({} as TValues)}
+        initialValues={initialData.data ?? ({} as TValues)}
         validationSchema={validationSchema}
         onSubmit={onSubmit}
         enableReinitialize={true}
       >
         <>
           {validationWatcher}
-          <SaveOnNavigate isSubmitting={isFormSubmitting} />
-          <FormStationContextProvider<TValues>
-            autosave={autosave}
-            currentValuesRef={currentValuesRef}
-          >
-            <FormStationHeader
-              titleProperty={titleProperty as string}
-              defaultTitle={defaultTitle}
-              subtitle={subtitle}
-              cancelNavigationUrl={cancelNavigationUrl}
-              isFormSubmitting={isFormSubmitting}
-            />
-            <FormContentWrapper
-              stationMessage={stationMessage}
-              edgeToEdgeContent={edgeToEdgeContent}
-              infoPanel={infoPanel}
-              initialData={initialData}
-              stationError={stationError}
+          <FormStationHeader
+            titleProperty={titleProperty as string}
+            defaultTitle={defaultTitle}
+            subtitle={subtitle}
+            cancelNavigationUrl={cancelNavigationUrl}
+          />
+          {stationError && (
+            <div className={classes.errorMessage}>
+              <MessageBar
+                type="error"
+                title={String(stationError.title)}
+                onClose={() => setStationError(undefined)}
+              >
+                {stationError?.body}
+              </MessageBar>
+            </div>
+          )}
+          <div className={classes.children}>{getContent()}</div>
+          {alwaysShowActionsPanel || (actions?.length ?? 0) > 0 ? (
+            <FormStationAction<TValues, TSubmitResponse>
+              actions={actions}
+              width={actionsWidth}
+              validationSchema={validationSchema}
               setStationError={setStationError}
-            >
-              {children}
-            </FormContentWrapper>
-            {alwaysShowActionsPanel || (actions?.length ?? 0) > 0 ? (
-              <FormStationActions<TValues, TSubmitResponse>
-                actions={actions}
-                width={actionsWidth}
-                validationSchema={validationSchema}
-                setStationError={setStationError}
-                setValidationError={setValidationError}
-                submitResponse={lastSubmittedResponse}
-                alwaysSubmitBeforeAction={alwaysSubmitBeforeAction}
-                className={classes.actionsPanel}
-              />
-            ) : null}
-          </FormStationContextProvider>
+              setValidationError={setValidationError}
+              submitResponse={submitResponse}
+              alwaysSubmitBeforeAction={alwaysSubmitBeforeAction}
+              className={classes.actionsPanel}
+            />
+          ) : null}
         </>
       </Formik>
     </div>
   );
 };
+
+/**
+ * Saves the form before the action is performed.
+ */
+const FormStationAction = <T, Y>(
+  props: PropsWithChildren<FormActionProps<T, Y>>,
+): JSX.Element => {
+  const {
+    actions,
+    validationSchema,
+    setStationError,
+    setValidationError,
+    submitResponse,
+    alwaysSubmitBeforeAction,
+    className = '',
+  } = props;
+  const {
+    submitForm,
+    resetForm,
+    values,
+    validateForm,
+    isValid,
+    dirty,
+    isSubmitting,
+  } = useFormikContext<T>();
+
+  const updatedActions = useMemo(() => {
+    return actions?.map((action) => {
+      const { onActionSelected } = action;
+
+      return isNavigationAction(action)
+        ? action
+        : {
+            ...action,
+            isDisabled: action.isDisabled || isSubmitting,
+            onActionSelected: () => {
+              (async () => {
+                //TODO: Busy indicator (disable form?)
+                if (dirty || alwaysSubmitBeforeAction) {
+                  // We can't rely on 'isValid' alone, since that will only evaluate if the form is touched or 'submitForm' is called.
+                  // On a create station though the from might not be touched but still being invalid.
+                  // Also the validation on submitForm in here will not help, since the value of isValid is already bound to that method and will not change
+                  // anymore while this method executes - even if it changes on the context!
+                  if (
+                    !isValid ||
+                    (await validationSchema?.isValid(values)) === false
+                  ) {
+                    setValidationError();
+                    // Making sure that the fields will actually show the validation messages (they won't if the from was not touched yet - e.g. on a create station)
+                    validateForm();
+                    return;
+                  }
+
+                  try {
+                    await submitForm();
+
+                    // Committing the changed values to the form to get the current version as the new "reset" state.
+                    resetForm({ values });
+                  } catch (error) {
+                    // we will abort the action if saving is not successful
+                    // a station error is already set by the "onSubmit"
+                    return;
+                  }
+                }
+
+                try {
+                  const result =
+                    onActionSelected &&
+                    (await onActionSelected({
+                      values,
+                      submitResponse: submitResponse?.current,
+                    }));
+                  if (result !== undefined) {
+                    setStationError(
+                      ErrorTypeToStationError(
+                        result,
+                        'An error occurred when trying to execute the action.',
+                      ),
+                    );
+                  }
+                } catch (error) {
+                  const stationError = ErrorTypeToStationError(
+                    error as ErrorType,
+                    'An error occurred when trying to execute the action.',
+                  );
+                  setStationError(stationError);
+                }
+              })();
+            },
+          };
+    });
+  }, [
+    actions,
+    alwaysSubmitBeforeAction,
+    dirty,
+    isSubmitting,
+    isValid,
+    resetForm,
+    setStationError,
+    setValidationError,
+    submitForm,
+    submitResponse,
+    validateForm,
+    validationSchema,
+    values,
+  ]);
+
+  return (
+    <div className={className}>
+      <Actions actions={updatedActions} />
+    </div>
+  );
+};
+
+/**
+ * Handles showRefresh and cancel buttons based on form states
+ */
+const FormStationHeader: React.FC<
+  Omit<PageHeaderProps, 'title'> & {
+    titleProperty?: string;
+    defaultTitle?: string;
+    cancelNavigationUrl?: string;
+  }
+> = ({ titleProperty, defaultTitle, subtitle, cancelNavigationUrl }) => {
+  const { dirty, resetForm, values } = useFormikContext<FormikValues>();
+
+  useEffect(() => {
+    // Set the save indicator to dirty depending on the form state
+    if (dirty) {
+      setSaveIndicator(SaveIndicatorType.Dirty);
+    } else {
+      setSaveIndicator(SaveIndicatorType.Inactive);
+    }
+    return () => {
+      // The form is not always considered "not dirty" after the save
+      // so this code will make sure that the indicator is set to inactive
+      // when the station is left.
+      setSaveIndicator(SaveIndicatorType.Inactive);
+    };
+  }, [dirty]);
+
+  const history = useHistory();
+
+  const title =
+    titleProperty && values[titleProperty] !== ''
+      ? values[titleProperty]
+      : defaultTitle ?? '';
+
+  return (
+    <PageHeader
+      title={title}
+      subtitle={subtitle}
+      actions={[
+        ...(dirty === true // add undo action if form as been altered
+          ? [
+              {
+                label: 'Undo Changes',
+                icon: IconName.Undo,
+                actionType: PageHeaderActionType.Context,
+                onClick: () => {
+                  resetForm();
+                },
+              },
+            ]
+          : []),
+        ...(cancelNavigationUrl // add cancel action if applicable
+          ? [
+              {
+                label: 'Cancel',
+                icon: IconName.X,
+                onClick: () => {
+                  resetForm();
+                  // If the form has errors, Navigation needs to be wrapped in a promise or timeout.
+                  Promise.resolve().then(() =>
+                    history.push(cancelNavigationUrl),
+                  );
+                },
+              },
+            ]
+          : []),
+      ]}
+    />
+  );
+};

package/src/components/FormStation/StationErrorStateType.tsx

@@ -0,0 +1,5 @@
+import { StationError } from '../models';
+
+export interface StationErrorStateType extends StationError {
+  type?: string;
+}

package/src/components/FormStation/index.ts

@@ -1,4 +1,8 @@
 export { Create, CreateProps } from './Create/Create';
 export { Details, DetailsProps } from './Details/Details';
-export { FormStation, FormStationProps } from './FormStation';
+export {
+  FormStation,
+  FormStationProps,
+  ObjectSchemaDefinition,
+} from './FormStation';
 export * from './FormStation.models';

package/src/components/FormStation/{helpers/useValidationError.tsx → useValidationError.tsx}

@@ -1,6 +1,6 @@
 import { useFormikContext } from 'formik';
 import React, { useCallback, useEffect, useState } from 'react';
-import type { StationErrorStateType } from '../FormStation.models';
+import { StationErrorStateType } from './StationErrorStateType';
 
 /**
  * Component that watches for changes in the form validation state

package/src/components/Utils/Postgraphile/getArrayDiff.ts

@@ -1,4 +1,3 @@
-import { isEqual } from 'lodash';
 /**
  * Compares two arrays and returns an object holding an array for the added and another one for the removed items.
  *
@@ -54,9 +53,9 @@ export function getArrayDiff<T>(
     (x: T) =>
       !originalArray.find((e) => {
         if (key) {
-          return isEqual(e[key], x[key]);
+          return e[key] === x[key];
         }
-        return isEqual(e, x);
+        return e === x;
       }),
   );
 
@@ -64,9 +63,9 @@ export function getArrayDiff<T>(
     (x: T) =>
       !currentArray.find((e) => {
         if (key && typeof key === 'string') {
-          return isEqual(e[key], x[key]);
+          return e[key] === x[key];
         }
-        return isEqual(e, x);
+        return e === x;
       }),
   );
 
@@ -75,7 +74,7 @@ export function getArrayDiff<T>(
   if (key && typeof key === 'string') {
     updated.push(
       ...currentArray.filter((x: T) =>
-        originalArray.find((e) => isEqual(e[key], x[key]) && isUpdated(e, x)),
+        originalArray.find((e) => e[key] === x[key] && isUpdated(e, x)),
       ),
     );
   }
@@ -88,7 +87,7 @@ function isUpdated<U>(x: U, y: U): boolean {
 
   if (isObject(x) && isObject(y)) {
     Object.keys(x).forEach((key) => {
-      if (!isEqual(x[key], y[key])) {
+      if (x[key] !== y[key]) {
         value = true;
       }
     });

package/src/components/Utils/Postgraphile/getFormDiff.ts

@@ -1,5 +1,4 @@
 import { FormikValues } from 'formik';
-import { isEqual } from 'lodash';
 
 /**
  * Returns an object only containing the differences between the two FormikValues.
@@ -20,7 +19,7 @@ export function getFormDiff<T extends FormikValues>(
 ): Partial<T> {
   const updateData = initial
     ? Object.keys(current).reduce<T>((result, value) => {
-        if (!isEqual(current[value], initial[value])) {
+        if (current[value] !== initial[value]) {
           result[value as keyof T] = current[value];
         }
         return result;

package/dist/components/FormStation/FormContentWrapper/FormContentWrapper.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import type { Data } from '../../../types';
-import type { FormStationProps } from '../FormStation';
-import type { StationErrorStateType } from '../FormStation.models';
-interface FormContentWrapperProps extends Pick<FormStationProps<Data>, 'stationMessage' | 'edgeToEdgeContent' | 'infoPanel' | 'initialData'> {
-    stationError?: StationErrorStateType;
-    setStationError: React.Dispatch<React.SetStateAction<StationErrorStateType | undefined>>;
-}
-export declare const FormContentWrapper: React.FC<FormContentWrapperProps>;
-export {};
-//# sourceMappingURL=FormContentWrapper.d.ts.map

package/dist/components/FormStation/FormContentWrapper/FormContentWrapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FormContentWrapper.d.ts","sourceRoot":"","sources":["../../../../src/components/FormStation/FormContentWrapper/FormContentWrapper.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAGnE,UAAU,uBACR,SAAQ,IAAI,CACV,gBAAgB,CAAC,IAAI,CAAC,EACtB,gBAAgB,GAAG,mBAAmB,GAAG,WAAW,GAAG,aAAa,CACrE;IACD,YAAY,CAAC,EAAE,qBAAqB,CAAC;IACrC,eAAe,EAAE,KAAK,CAAC,QAAQ,CAC7B,KAAK,CAAC,cAAc,CAAC,qBAAqB,GAAG,SAAS,CAAC,CACxD,CAAC;CACH;AAED,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC,uBAAuB,CAwDhE,CAAC"}

package/dist/components/FormStation/FormStationActions/FormStationActions.d.ts

@@ -1,21 +0,0 @@
-import React, { PropsWithChildren } from 'react';
-import { OptionalObjectSchema } from 'yup/lib/object';
-import { ActionsProps } from '../../Actions';
-import { StationError } from '../../models';
-import { FormActionData, ObjectSchemaDefinition } from '../FormStation.models';
-interface FormActionProps<T, Y> extends Omit<ActionsProps, 'actions'> {
-    validationSchema?: OptionalObjectSchema<ObjectSchemaDefinition<any>>;
-    actions?: FormActionData<T, Y>[];
-    setStationError: (error: StationError) => void;
-    setValidationError: () => void;
-    submitResponse?: React.MutableRefObject<Y | undefined>;
-    alwaysSubmitBeforeAction?: boolean;
-    className?: string;
-    isFormSubmitting?: boolean;
-}
-/**
- * Saves the form before the action is performed.
- */
-export declare const FormStationActions: <T, Y>(props: React.PropsWithChildren<FormActionProps<T, Y>>) => JSX.Element;
-export {};
-//# sourceMappingURL=FormStationActions.d.ts.map

package/dist/components/FormStation/FormStationActions/FormStationActions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FormStationActions.d.ts","sourceRoot":"","sources":["../../../../src/components/FormStation/FormStationActions/FormStationActions.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,iBAAiB,EAAW,MAAM,OAAO,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEtD,OAAO,EAAW,YAAY,EAAE,MAAM,eAAe,CAAC;AAEtD,OAAO,EAAa,YAAY,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/E,UAAU,eAAe,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC;IAEnE,gBAAgB,CAAC,EAAE,oBAAoB,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC;IACrE,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;IACjC,eAAe,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC/C,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,cAAc,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IACvD,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,mEAE5B,WAyGF,CAAC"}

package/dist/components/FormStation/FormStationContext/FormStationContext.d.ts

@@ -1,13 +0,0 @@
-import type { FormikValues } from 'formik';
-import React from 'react';
-import { ChangeSet } from '../helpers/useChangeSets';
-export interface FormStationContextType {
-    changeSets: ChangeSet<FormikValues>[];
-    pushChangeSet: (value: never) => void;
-    popChangeSet: () => ChangeSet<FormikValues> | undefined;
-    clearChangeSets: () => FormikValues;
-    lastUndoneValue: React.MutableRefObject<FormikValues>;
-    autosave: boolean;
-}
-export declare const FormStationContext: React.Context<FormStationContextType>;
-//# sourceMappingURL=FormStationContext.d.ts.map

package/dist/components/FormStation/FormStationContext/FormStationContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FormStationContext.d.ts","sourceRoot":"","sources":["../../../../src/components/FormStation/FormStationContext/FormStationContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAC3C,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC;IACtC,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACtC,YAAY,EAAE,MAAM,SAAS,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC;IACxD,eAAe,EAAE,MAAM,YAAY,CAAC;IACpC,eAAe,EAAE,KAAK,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;IACtD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,kBAAkB,uCAO7B,CAAC"}

package/dist/components/FormStation/FormStationContext/FormStationContextProvider.d.ts

@@ -1,10 +0,0 @@
-import React, { PropsWithChildren } from 'react';
-import { Data } from '../../../types';
-interface FormStationContextProviderProps<TValues extends Data> {
-    autosave?: boolean;
-    autosaveDelay?: number;
-    currentValuesRef?: React.MutableRefObject<Partial<TValues>>;
-}
-export declare const FormStationContextProvider: <TValues extends Data>({ children, autosave, autosaveDelay, currentValuesRef, }: React.PropsWithChildren<FormStationContextProviderProps<TValues>>) => JSX.Element;
-export {};
-//# sourceMappingURL=FormStationContextProvider.d.ts.map