@amp-labs/react 1.0.0

package/build/src/components/Configure/fields/OptionalFields.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalFields = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("@chakra-ui/react");
+const ProjectContext_1 = require("../../../context/ProjectContext");
+const ObjectManagementNav_1 = require("../ObjectManagementNav");
+const ConfigurationStateProvider_1 = require("../state/ConfigurationStateProvider");
+const utils_1 = require("../state/utils");
+const utils_2 = require("../utils");
+const FieldHeader_1 = require("./FieldHeader");
+function OptionalFields() {
+    var _a;
+    const { appName } = (0, ProjectContext_1.useProject)();
+    const { objectConfigurationsState, setConfigureState } = (0, ConfigurationStateProvider_1.useConfigureState)();
+    const { selectedObjectName } = (0, ObjectManagementNav_1.useSelectedObjectName)();
+    const configureState = (0, utils_1.getConfigureState)(selectedObjectName || '', objectConfigurationsState);
+    const { selectedOptionalFields } = configureState || {};
+    const onCheckboxChange = (e) => {
+        var _a;
+        const { name, checked } = e.target;
+        if (selectedObjectName && configureState) {
+            // Update the value property to new checked value
+            const updatedSelectOptionalFields = Object.assign(Object.assign({}, selectedOptionalFields), { [name]: checked });
+            // removed from check fields if not checked
+            if (!checked) {
+                delete updatedSelectOptionalFields[name];
+            }
+            // Compare saved fields from updated fields
+            const savedOptionalFields = (_a = configureState.savedConfig) === null || _a === void 0 ? void 0 : _a.optionalFields;
+            // Check if the optionalFields are modified
+            const isModified = !(0, utils_1.checkFieldsEquality)(savedOptionalFields, updatedSelectOptionalFields);
+            // update state
+            setConfigureState(selectedObjectName, Object.assign(Object.assign({}, configureState), { selectedOptionalFields: updatedSelectOptionalFields, isOptionalFieldsModified: isModified }));
+        }
+    };
+    const shouldRender = !!((configureState === null || configureState === void 0 ? void 0 : configureState.optionalFields) && (configureState === null || configureState === void 0 ? void 0 : configureState.optionalFields));
+    return (shouldRender && ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(FieldHeader_1.FieldHeader, { string: `${appName} reads the following optional fields` }), (0, jsx_runtime_1.jsx)(react_1.Stack, { marginBottom: 10, height: 300, overflowY: "scroll", border: "2px solid #EFEFEF", borderRadius: 8, padding: 4, children: (_a = configureState === null || configureState === void 0 ? void 0 : configureState.optionalFields) === null || _a === void 0 ? void 0 : _a.map((field) => {
+                    if (!(0, utils_2.isIntegrationFieldMapping)(field)) {
+                        return ((0, jsx_runtime_1.jsx)(react_1.Box, { display: "flex", gap: "5px", borderBottom: "1px", borderColor: "gray.100", children: (0, jsx_runtime_1.jsx)(react_1.Checkbox, { name: field.fieldName, id: field.fieldName, isChecked: !!(selectedOptionalFields === null || selectedOptionalFields === void 0 ? void 0 : selectedOptionalFields[field === null || field === void 0 ? void 0 : field.fieldName]), onChange: onCheckboxChange, children: field.displayName }) }, field.fieldName));
+                    }
+                    return null; // fallback for customed mapped fields
+                }) })] })));
+}
+exports.OptionalFields = OptionalFields;

package/build/src/components/Configure/fields/RequiredFieldMappings.d.ts

@@ -0,0 +1 @@
+export declare function RequiredFieldMappings(): import("react/jsx-runtime").JSX.Element | null;

package/build/src/components/Configure/fields/RequiredFieldMappings.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredFieldMappings = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_2 = require("@chakra-ui/react");
+const ErrorContextProvider_1 = require("../../../context/ErrorContextProvider");
+const ObjectManagementNav_1 = require("../ObjectManagementNav");
+const ConfigurationStateProvider_1 = require("../state/ConfigurationStateProvider");
+const utils_1 = require("../state/utils");
+const utils_2 = require("../utils");
+const FieldHeader_1 = require("./FieldHeader");
+const FieldMapping_1 = require("./FieldMapping");
+function RequiredFieldMappings() {
+    const { selectedObjectName } = (0, ObjectManagementNav_1.useSelectedObjectName)();
+    const { objectConfigurationsState, setConfigureState } = (0, ConfigurationStateProvider_1.useConfigureState)();
+    const configureState = (0, utils_1.getConfigureState)(selectedObjectName || '', objectConfigurationsState);
+    const { isError, removeError } = (0, ErrorContextProvider_1.useErrorState)();
+    const onSelectChange = (e) => {
+        const { value, name } = e.target;
+        if (!value) {
+            // if place holder value is chosen, we don't change state
+            return;
+        }
+        const { isUpdated, newState } = (0, utils_1.setRequiredCustomMapFieldValue)(name, value, configureState);
+        if (isUpdated && selectedObjectName) {
+            setConfigureState(selectedObjectName, newState);
+        }
+        if (isError(ErrorContextProvider_1.ErrorBoundary.MAPPING, name)) {
+            removeError(ErrorContextProvider_1.ErrorBoundary.MAPPING, name);
+        }
+    };
+    const integrationFieldMappings = (0, react_1.useMemo)(() => {
+        var _a;
+        return ((_a = configureState === null || configureState === void 0 ? void 0 : configureState.requiredMapFields) === null || _a === void 0 ? void 0 : _a.filter(utils_2.isIntegrationFieldMapping)) || [];
+    }, [configureState]);
+    return (integrationFieldMappings.length ? ((0, jsx_runtime_1.jsxs)(react_2.Box, { children: [(0, jsx_runtime_1.jsx)(FieldHeader_1.FieldHeader, { string: "Map the following fields (required)" }), (0, jsx_runtime_1.jsx)(react_2.Stack, { children: integrationFieldMappings.map((field) => ((0, jsx_runtime_1.jsxs)(react_2.FormControl, { isInvalid: isError(ErrorContextProvider_1.ErrorBoundary.MAPPING, field.mapToName), children: [(0, jsx_runtime_1.jsx)(FieldMapping_1.FieldMapping, { allFields: configureState.allFields || [], field: field, onSelectChange: onSelectChange }), (0, jsx_runtime_1.jsx)(react_2.FormErrorMessage, { children: " * required" })] }, field.mapToName))) })] }))
+        : null);
+}
+exports.RequiredFieldMappings = RequiredFieldMappings;

package/build/src/components/Configure/fields/RequiredFields.d.ts

@@ -0,0 +1 @@
+export declare function RequiredFields(): import("react/jsx-runtime").JSX.Element;

package/build/src/components/Configure/fields/RequiredFields.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredFields = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("@chakra-ui/react");
+const ProjectContext_1 = require("../../../context/ProjectContext");
+const ObjectManagementNav_1 = require("../ObjectManagementNav");
+const ConfigurationStateProvider_1 = require("../state/ConfigurationStateProvider");
+const utils_1 = require("../state/utils");
+const utils_2 = require("../utils");
+const FieldHeader_1 = require("./FieldHeader");
+function RequiredFields() {
+    var _a;
+    const { selectedObjectName } = (0, ObjectManagementNav_1.useSelectedObjectName)();
+    const { objectConfigurationsState } = (0, ConfigurationStateProvider_1.useConfigureState)();
+    const configureState = (0, utils_1.getConfigureState)(selectedObjectName || '', objectConfigurationsState);
+    const { appName } = (0, ProjectContext_1.useProject)();
+    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(FieldHeader_1.FieldHeader, { string: `${appName} reads the following ${selectedObjectName} fields` }), (0, jsx_runtime_1.jsx)(react_1.Box, { marginBottom: "20px", children: ((_a = configureState === null || configureState === void 0 ? void 0 : configureState.requiredFields) === null || _a === void 0 ? void 0 : _a.length)
+                    ? (configureState.requiredFields.map((field) => {
+                        if (!(0, utils_2.isIntegrationFieldMapping)(field)) {
+                            return (0, jsx_runtime_1.jsx)(react_1.Tag, { children: field.displayName }, field.fieldName);
+                        }
+                        return null; // fallback for customed mapped fields
+                    }))
+                    : 'There are no required fields.' })] }));
+}
+exports.RequiredFields = RequiredFields;

package/build/src/components/Configure/index.d.ts

@@ -0,0 +1 @@
+export { InstallIntegration } from './InstallIntegration';

package/build/src/components/Configure/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstallIntegration = void 0;
+var InstallIntegration_1 = require("./InstallIntegration");
+Object.defineProperty(exports, "InstallIntegration", { enumerable: true, get: function () { return InstallIntegration_1.InstallIntegration; } });

package/build/src/components/Configure/state/ConfigurationStateProvider.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { ConfigureState, ObjectConfigurationsState } from '../types';
+export declare function useConfigureState(): {
+    objectConfigurationsState: ObjectConfigurationsState;
+    setObjectConfigurationsState: React.Dispatch<React.SetStateAction<ObjectConfigurationsState>>;
+    setConfigureState: (objectName: string, configureState: ConfigureState) => void;
+    resetPendingConfigurationState: (objectName: string) => void;
+};
+type ConfigurationProviderProps = {
+    children: React.ReactNode;
+};
+export declare function ConfigurationProvider({ children }: ConfigurationProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/src/components/Configure/state/ConfigurationStateProvider.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationProvider = exports.useConfigureState = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const InstallIntegrationContext_1 = require("../../../context/InstallIntegrationContext");
+const HydratedRevisionContext_1 = require("./HydratedRevisionContext");
+const utils_1 = require("./utils");
+// Create a context for the configuration state
+const ConfigurationContext = (0, react_1.createContext)(undefined);
+const initialObjectConfigurationsState = {};
+// Custom hook to access and update the configuration state
+function useConfigureState() {
+    const context = (0, react_1.useContext)(ConfigurationContext);
+    if (!context) {
+        throw new Error('useConfigureState must be used within a ConfigurationProvider');
+    }
+    return context;
+}
+exports.useConfigureState = useConfigureState;
+// Create a provider component for the configuration context
+function ConfigurationProvider({ children }) {
+    const { installation } = (0, InstallIntegrationContext_1.useInstallIntegrationProps)();
+    const { hydratedRevision, loading } = (0, HydratedRevisionContext_1.useHydratedRevision)();
+    // 1. get config from installations (contains form selection state)
+    // 2. get the hydrated revision from installation revisionId (contains full form)
+    // 3. generate the configuration state from the hydrated revision and config
+    const [objectConfigurationsState, setObjectConfigurationsState,] = (0, react_1.useState)(initialObjectConfigurationsState);
+    const config = installation === null || installation === void 0 ? void 0 : installation.config;
+    (0, react_1.useEffect)(() => {
+        // set configurationState when hydratedRevision is loaded
+        // only reset when objectConfigurationsState does not exist
+        if ((hydratedRevision === null || hydratedRevision === void 0 ? void 0 : hydratedRevision.content) && !loading && config && !objectConfigurationsState) {
+            (0, utils_1.resetAllObjectsConfigurationState)(hydratedRevision, config, setObjectConfigurationsState);
+        }
+    }, [hydratedRevision, loading, config, objectConfigurationsState]);
+    // set configure state of single object
+    const setConfigureState = (0, react_1.useCallback)((objectName, configureState) => {
+        // consider moving check modified state here
+        setObjectConfigurationsState((prevState) => (Object.assign(Object.assign({}, prevState), { [objectName]: configureState })));
+    }, [setObjectConfigurationsState]);
+    // set configure state of single object
+    const resetPendingConfigurationState = (0, react_1.useCallback)((objectName) => {
+        setObjectConfigurationsState((prevObjectsConfigurationsState) => (Object.assign(Object.assign({}, prevObjectsConfigurationsState), { [objectName]: Object.assign(Object.assign({}, prevObjectsConfigurationsState[objectName]), { isOptionalFieldsModified: false, isRequiredMapFieldsModified: false }) })));
+    }, [setObjectConfigurationsState]);
+    const contextValue = (0, react_1.useMemo)(() => ({
+        objectConfigurationsState,
+        setObjectConfigurationsState,
+        setConfigureState,
+        resetPendingConfigurationState,
+    }), [objectConfigurationsState, resetPendingConfigurationState, setConfigureState]);
+    return ((0, jsx_runtime_1.jsx)(ConfigurationContext.Provider, { value: contextValue, children: children }));
+}
+exports.ConfigurationProvider = ConfigurationProvider;

package/build/src/components/Configure/state/HydratedRevisionContext.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { HydratedRevision } from '../../../services/api';
+interface HydratedRevisionContextValue {
+    hydratedRevision: HydratedRevision | null;
+    loading: boolean;
+}
+export declare const HydratedRevisionContext: React.Context<HydratedRevisionContextValue>;
+export declare const useHydratedRevision: () => HydratedRevisionContextValue;
+type HydratedRevisionProviderProps = {
+    projectId?: string | null;
+    children?: React.ReactNode;
+};
+export declare function HydratedRevisionProvider({ projectId, children, }: HydratedRevisionProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/src/components/Configure/state/HydratedRevisionContext.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HydratedRevisionProvider = exports.useHydratedRevision = exports.HydratedRevisionContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const ApiKeyContext_1 = require("../../../context/ApiKeyContext");
+const ConnectionsContext_1 = require("../../../context/ConnectionsContext");
+const ErrorContextProvider_1 = require("../../../context/ErrorContextProvider");
+const InstallIntegrationContext_1 = require("../../../context/InstallIntegrationContext");
+const IntegrationListContext_1 = require("../../../context/IntegrationListContext");
+const api_1 = require("../../../services/api");
+const ErrorTextBox_1 = require("../ErrorTextBox");
+exports.HydratedRevisionContext = (0, react_1.createContext)({
+    hydratedRevision: null,
+    loading: false,
+});
+const useHydratedRevision = () => {
+    const context = (0, react_1.useContext)(exports.HydratedRevisionContext);
+    if (!context) {
+        throw new Error('useHydratedRevision must be used within a HydratedRevisionProvider');
+    }
+    return context;
+};
+exports.useHydratedRevision = useHydratedRevision;
+function HydratedRevisionProvider({ projectId, children, }) {
+    var _a;
+    const { integrationId, integrationObj } = (0, InstallIntegrationContext_1.useInstallIntegrationProps)();
+    const { integrations } = (0, IntegrationListContext_1.useIntegrationList)();
+    const [hydratedRevision, setHydratedRevision] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const { isError, removeError, setError } = (0, ErrorContextProvider_1.useErrorState)();
+    const apiKey = (0, react_1.useContext)(ApiKeyContext_1.ApiKeyContext);
+    const { selectedConnection } = (0, ConnectionsContext_1.useConnections)();
+    const connectionId = selectedConnection === null || selectedConnection === void 0 ? void 0 : selectedConnection.id;
+    const revisionId = (_a = integrationObj === null || integrationObj === void 0 ? void 0 : integrationObj.latestRevision) === null || _a === void 0 ? void 0 : _a.id;
+    const errorIntegrationIdentifier = (integrationObj === null || integrationObj === void 0 ? void 0 : integrationObj.name) || integrationId;
+    (0, react_1.useEffect)(() => {
+        // Fetch the hydrated revision data using your API call
+        if (projectId
+            && integrationId
+            && revisionId
+            && connectionId
+            && apiKey) {
+            (0, api_1.api)().getHydratedRevision({
+                projectId,
+                integrationId,
+                revisionId,
+                connectionId,
+            }, {
+                headers: {
+                    'X-Api-Key': apiKey !== null && apiKey !== void 0 ? apiKey : '',
+                },
+            })
+                .then((data) => {
+                setHydratedRevision(data);
+                setLoading(false);
+                removeError(ErrorContextProvider_1.ErrorBoundary.HYDRATED_REVISION, errorIntegrationIdentifier);
+            })
+                .catch((err) => {
+                console.error(`Error loading integration ${errorIntegrationIdentifier}`, err);
+                setLoading(false);
+                setError(ErrorContextProvider_1.ErrorBoundary.HYDRATED_REVISION, errorIntegrationIdentifier);
+            });
+        }
+    }, [
+        projectId,
+        integrationId,
+        revisionId,
+        connectionId,
+        apiKey,
+        integrations,
+        removeError,
+        setError,
+        errorIntegrationIdentifier
+    ]);
+    const contextValue = (0, react_1.useMemo)(() => ({
+        hydratedRevision,
+        loading,
+    }), [hydratedRevision, loading]);
+    return ((0, jsx_runtime_1.jsx)(exports.HydratedRevisionContext.Provider, { value: contextValue, children: isError(ErrorContextProvider_1.ErrorBoundary.HYDRATED_REVISION, errorIntegrationIdentifier) ? (0, jsx_runtime_1.jsx)(ErrorTextBox_1.ErrorTextBox, { message: `Error retrieving integration details for '${(integrationObj === null || integrationObj === void 0 ? void 0 : integrationObj.name) || integrationId || 'unknown integration'}. This is sometimes caused by insufficient permissions with your credentials'` }) : children }));
+}
+exports.HydratedRevisionProvider = HydratedRevisionProvider;

package/build/src/components/Configure/state/utils.d.ts

@@ -0,0 +1,34 @@
+import { Config, HydratedIntegrationRead, HydratedRevision } from '../../../services/api';
+import { ConfigureState, ConfigureStateMappingIntegrationField, ObjectConfigurationsState, SavedConfigureFields } from '../types';
+export declare function createSavedFields(fields: ConfigureStateMappingIntegrationField[] | null | undefined): SavedConfigureFields;
+export declare function checkFieldsEquality(prevFields: SavedConfigureFields, currentFields: SavedConfigureFields): boolean;
+export declare function generateConfigurationState(action: HydratedIntegrationRead, objectName: string, config?: Config): ConfigureState;
+export declare const resetConfigurationState: (hydratedRevision: HydratedRevision, config: Config | undefined, selectedObjectName: string, setConfigureState: (objectName: string, configureState: ConfigureState) => void) => void;
+/**
+ * resets configure state for all objects in hydrated revision to hydrated revision values
+ */
+export declare const resetAllObjectsConfigurationState: (hydratedRevision: HydratedRevision, config: Config | undefined, setObjectConfiguresState: React.Dispatch<React.SetStateAction<ObjectConfigurationsState>>) => void;
+/**
+ * generates selectedFields object for Config from configureState
+ * @param configureState
+ * @returns
+ */
+export declare const generateSelectedFieldsFromConfigureState: (configureState: ConfigureState) => {};
+/**
+ * generates selectedFieldMappings object for Config from configureState
+ * @param configureState
+ * @returns
+ */
+export declare const generateSelectedFieldMappingsFromConfigureState: (configureState: ConfigureState) => {};
+/**
+ * returns a new configure state with one of its FieldMappings updated with a new value.
+ * @param fieldKey
+ * @param value
+ * @param configureState
+ * @returns
+ */
+export declare const setRequiredCustomMapFieldValue: (fieldKey: string, value: string, configureState: ConfigureState) => {
+    isUpdated: boolean;
+    newState: ConfigureState;
+};
+export declare function getConfigureState(objectName: string, objectConfigurationsState: ObjectConfigurationsState): ConfigureState;

package/build/src/components/Configure/state/utils.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigureState = exports.setRequiredCustomMapFieldValue = exports.generateSelectedFieldMappingsFromConfigureState = exports.generateSelectedFieldsFromConfigureState = exports.resetAllObjectsConfigurationState = exports.resetConfigurationState = exports.generateConfigurationState = exports.checkFieldsEquality = exports.createSavedFields = void 0;
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+const utils_1 = require("../utils");
+function createSavedFields(fields) {
+    const savedFields = {};
+    fields === null || fields === void 0 ? void 0 : fields.forEach((field) => {
+        const { value } = field;
+        if (value) {
+            savedFields[field.mapToName] = value;
+        }
+    });
+    return savedFields;
+}
+exports.createSavedFields = createSavedFields;
+// uses lodash deep equality check to compare two saved fields objects
+function checkFieldsEquality(prevFields, currentFields) {
+    return (0, lodash_isequal_1.default)(prevFields, currentFields);
+}
+exports.checkFieldsEquality = checkFieldsEquality;
+function generateConfigurationState(action, objectName, config) {
+    var _a, _b, _c, _d, _e;
+    const object = (0, utils_1.getStandardObjectFromAction)(action, objectName);
+    const requiredFields = object && (0, utils_1.getRequiredFieldsFromObject)(object);
+    const optionalFields = object && (0, utils_1.getOptionalFieldsFromObject)(object);
+    // todo refactor requiredMapFields to separate form state from hydrated revision
+    // map over requiredMapFields and get value from config
+    const requiredMapFields = object ? (_a = (0, utils_1.getRequiredMapFieldsFromObject)(object)) === null || _a === void 0 ? void 0 : _a.map((field) => (Object.assign(Object.assign({}, field), { value: config ? (0, utils_1.getValueFromConfigCustomMapping)(config, objectName, 
+        // should only use mapToName for custom mapping fields
+        (0, utils_1.getFieldKeyValue)(field)) : '' }))) : null; // type hack - TODO fix
+    const allFields = (object === null || object === void 0 ? void 0 : object.allFields) || [];
+    const selectedFields = ((_e = (_d = (_c = (_b = config === null || config === void 0 ? void 0 : config.content) === null || _b === void 0 ? void 0 : _b.read) === null || _c === void 0 ? void 0 : _c.standardObjects) === null || _d === void 0 ? void 0 : _d[objectName]) === null || _e === void 0 ? void 0 : _e.selectedFields) || {};
+    const optionalFieldsSaved = Object.assign({}, selectedFields);
+    const requiredMapFieldsSaved = createSavedFields(requiredMapFields);
+    return {
+        allFields,
+        requiredFields,
+        optionalFields,
+        requiredMapFields,
+        selectedOptionalFields: selectedFields,
+        isOptionalFieldsModified: false,
+        isRequiredMapFieldsModified: false,
+        savedConfig: {
+            optionalFields: optionalFieldsSaved,
+            requiredMapFields: requiredMapFieldsSaved, // from config
+        },
+    };
+}
+exports.generateConfigurationState = generateConfigurationState;
+// resets configure state for single object to hydrated revision values
+const resetConfigurationState = (hydratedRevision, config, selectedObjectName, setConfigureState) => {
+    var _a;
+    const readAction = (_a = hydratedRevision === null || hydratedRevision === void 0 ? void 0 : hydratedRevision.content) === null || _a === void 0 ? void 0 : _a.read;
+    if (!readAction) {
+        return;
+    }
+    const state = generateConfigurationState(readAction, selectedObjectName, config);
+    setConfigureState(selectedObjectName, state);
+};
+exports.resetConfigurationState = resetConfigurationState;
+/**
+ * resets configure state for all objects in hydrated revision to hydrated revision values
+ */
+const resetAllObjectsConfigurationState = (hydratedRevision, config, setObjectConfiguresState) => {
+    const navObjects = (0, utils_1.generateNavObjects)(config, hydratedRevision);
+    const objectConfigurationsState = {};
+    navObjects.forEach(({ name, completed }) => {
+        var _a;
+        const readAction = (_a = hydratedRevision === null || hydratedRevision === void 0 ? void 0 : hydratedRevision.content) === null || _a === void 0 ? void 0 : _a.read;
+        if (completed && readAction) {
+            objectConfigurationsState[name] = generateConfigurationState(readAction, name, config);
+        }
+    });
+    setObjectConfiguresState(objectConfigurationsState);
+};
+exports.resetAllObjectsConfigurationState = resetAllObjectsConfigurationState;
+/**
+ * generates selectedFields object for Config from configureState
+ * @param configureState
+ * @returns
+ */
+const generateSelectedFieldsFromConfigureState = (configureState) => {
+    const { requiredFields, selectedOptionalFields } = configureState;
+    const fields = new Set();
+    requiredFields === null || requiredFields === void 0 ? void 0 : requiredFields.forEach((field) => fields.add((0, utils_1.getFieldKeyValue)(field)));
+    // convert set to object for config
+    const selectedFields = Array.from(fields).reduce((acc, field) => (Object.assign(Object.assign({}, acc), { [field]: true })), {});
+    return Object.assign(Object.assign({}, selectedFields), (selectedOptionalFields || {}));
+};
+exports.generateSelectedFieldsFromConfigureState = generateSelectedFieldsFromConfigureState;
+/**
+ * generates selectedFieldMappings object for Config from configureState
+ * @param configureState
+ * @returns
+ */
+const generateSelectedFieldMappingsFromConfigureState = (configureState) => {
+    const { requiredMapFields } = configureState;
+    const requiredMapFieldsConfig = (requiredMapFields || []).reduce((acc, field) => {
+        const key = (0, utils_1.getFieldKeyValue)(field);
+        return Object.assign(Object.assign({}, acc), { [key]: field.value });
+    }, {});
+    return requiredMapFieldsConfig;
+};
+exports.generateSelectedFieldMappingsFromConfigureState = generateSelectedFieldMappingsFromConfigureState;
+/**
+ * returns a new configure state with one of its FieldMappings updated with a new value.
+ * @param fieldKey
+ * @param value
+ * @param configureState
+ * @returns
+ */
+const setRequiredCustomMapFieldValue = (fieldKey, value, configureState) => {
+    const { requiredMapFields } = configureState;
+    if (requiredMapFields === null) {
+        return { isUpdated: false, newState: configureState };
+    }
+    // flag to know if field was updated
+    let isUpdated = false;
+    const updatedRequiredMapFields = requiredMapFields.map((field) => {
+        // updated field
+        if (field.mapToName === fieldKey) {
+            isUpdated = true;
+            return Object.assign(Object.assign({}, field), { value });
+        }
+        // else return a copy of the field
+        return Object.assign({}, field);
+    });
+    if (isUpdated) {
+        const savedFields = configureState.savedConfig.requiredMapFields;
+        const updatedFields = createSavedFields(updatedRequiredMapFields);
+        const isModified = !checkFieldsEquality(savedFields, updatedFields);
+        const newState = Object.assign(Object.assign({}, configureState), { requiredMapFields: updatedRequiredMapFields, isRequiredMapFieldsModified: isModified });
+        return { isUpdated, newState };
+    }
+    return { isUpdated: false, newState: configureState };
+};
+exports.setRequiredCustomMapFieldValue = setRequiredCustomMapFieldValue;
+// get configure state of single object
+function getConfigureState(objectName, objectConfigurationsState) {
+    return objectConfigurationsState[objectName] || undefined;
+}
+exports.getConfigureState = getConfigureState;

package/build/src/components/Configure/types.d.ts

@@ -0,0 +1,31 @@
+import { HydratedIntegrationField, HydratedIntegrationFieldExistent, IntegrationFieldMapping } from '../../services/api';
+export type ConfigureStateIntegrationField = HydratedIntegrationFieldExistent & {
+    value: string | number | boolean | null;
+};
+export type ConfigureStateMappingIntegrationField = IntegrationFieldMapping & {
+    value: string | number | undefined;
+};
+export type SelectOptionalFields = {
+    [key: string]: boolean;
+};
+export type SavedConfigureFields = Record<string, string | number | boolean | null>;
+type SavedConfigureState = {
+    optionalFields: SelectOptionalFields;
+    requiredMapFields: SavedConfigureFields;
+};
+export type ConfigureState = {
+    allFields: HydratedIntegrationFieldExistent[] | null;
+    requiredFields: HydratedIntegrationField[] | null;
+    optionalFields: HydratedIntegrationField[] | null;
+    requiredMapFields: ConfigureStateMappingIntegrationField[] | null;
+    selectedOptionalFields: SelectOptionalFields | null;
+    isOptionalFieldsModified: boolean;
+    isRequiredMapFieldsModified: boolean;
+    savedConfig: SavedConfigureState;
+};
+export type ObjectConfigurationsState = Record<string, ConfigureState>;
+export type NavObject = {
+    name: string;
+    completed: boolean;
+};
+export {};

package/build/src/components/Configure/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/src/components/Configure/utils.d.ts

@@ -0,0 +1,24 @@
+import { Config, HydratedIntegrationField, HydratedIntegrationObject, HydratedIntegrationRead, HydratedRevision, IntegrationFieldMapping } from '../../services/api';
+import { NavObject } from './types';
+/**
+ * type guard for IntegrationFieldMapping | IntegrationFieldExistent
+ *
+ * @param field HydratedIntegrationField
+ * @returns
+ */
+export declare function isIntegrationFieldMapping(field: HydratedIntegrationField): field is IntegrationFieldMapping;
+/**
+ *
+ * @param action HydratedIntegrationAction
+ * @param objectName string (account, contect, etc...)
+ * @returns HydratedIntegrationObject | null
+ */
+export declare function getStandardObjectFromAction(action: HydratedIntegrationRead, objectName: string): HydratedIntegrationObject | null;
+export declare function getRequiredFieldsFromObject(object: HydratedIntegrationObject): HydratedIntegrationField[] | null;
+export declare function getRequiredMapFieldsFromObject(object: HydratedIntegrationObject): HydratedIntegrationField[] | null;
+export declare function getOptionalFieldsFromObject(object: HydratedIntegrationObject): HydratedIntegrationField[] | null;
+export declare const getReadObject: (config: Config, objectName: string) => any;
+export declare function getValueFromConfigExist(config: Config, objectName: string, key: string): boolean;
+export declare function getValueFromConfigCustomMapping(config: Config, objectName: string, key: string): string;
+export declare function getFieldKeyValue(field: HydratedIntegrationField): string;
+export declare function generateNavObjects(config: Config | undefined, hydratedRevision: HydratedRevision): NavObject[];

package/build/src/components/Configure/utils.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNavObjects = exports.getFieldKeyValue = exports.getValueFromConfigCustomMapping = exports.getValueFromConfigExist = exports.getReadObject = exports.getOptionalFieldsFromObject = exports.getRequiredMapFieldsFromObject = exports.getRequiredFieldsFromObject = exports.getStandardObjectFromAction = exports.isIntegrationFieldMapping = void 0;
+/**
+ * type guard for IntegrationFieldMapping | IntegrationFieldExistent
+ *
+ * @param field HydratedIntegrationField
+ * @returns
+ */
+function isIntegrationFieldMapping(field) {
+    return field.mapToName !== undefined;
+}
+exports.isIntegrationFieldMapping = isIntegrationFieldMapping;
+// 1. get standard object
+/**
+ *
+ * @param action HydratedIntegrationAction
+ * @param objectName string (account, contect, etc...)
+ * @returns HydratedIntegrationObject | null
+ */
+function getStandardObjectFromAction(action, objectName) {
+    var _a;
+    return ((_a = action === null || action === void 0 ? void 0 : action.standardObjects) === null || _a === void 0 ? void 0 : _a.find((object) => object.objectName === objectName)) || null;
+}
+exports.getStandardObjectFromAction = getStandardObjectFromAction;
+// 2a. get required fields
+function getRequiredFieldsFromObject(object) {
+    var _a;
+    return ((_a = object === null || object === void 0 ? void 0 : object.requiredFields) === null || _a === void 0 ? void 0 : _a.filter((rf) => !isIntegrationFieldMapping(rf) && !!rf.fieldName)) || null;
+}
+exports.getRequiredFieldsFromObject = getRequiredFieldsFromObject;
+// 2b. get required custom mapping fields
+function getRequiredMapFieldsFromObject(object) {
+    var _a;
+    return ((_a = object === null || object === void 0 ? void 0 : object.requiredFields) === null || _a === void 0 ? void 0 : _a.filter((rf) => isIntegrationFieldMapping(rf) && !!rf.mapToName)) || null;
+}
+exports.getRequiredMapFieldsFromObject = getRequiredMapFieldsFromObject;
+// 3. get optional fields
+function getOptionalFieldsFromObject(object) {
+    var _a;
+    return ((_a = object === null || object === void 0 ? void 0 : object.optionalFields) === null || _a === void 0 ? void 0 : _a.filter((rf) => !isIntegrationFieldMapping(rf) && !!rf.fieldName)) || null;
+}
+exports.getOptionalFieldsFromObject = getOptionalFieldsFromObject;
+const getReadObject = (config, objectName) => { var _a, _b, _c; return (_c = (_b = (_a = config === null || config === void 0 ? void 0 : config.content) === null || _a === void 0 ? void 0 : _a.read) === null || _b === void 0 ? void 0 : _b.standardObjects) === null || _c === void 0 ? void 0 : _c[objectName]; };
+exports.getReadObject = getReadObject;
+// 4a. get value for field
+function getValueFromConfigExist(config, objectName, key) {
+    var _a;
+    const object = (0, exports.getReadObject)(config, objectName);
+    return ((_a = object === null || object === void 0 ? void 0 : object.selectedFields) === null || _a === void 0 ? void 0 : _a[key]) || false;
+}
+exports.getValueFromConfigExist = getValueFromConfigExist;
+// 4b. get value for custom mapping field
+function getValueFromConfigCustomMapping(config, objectName, key) {
+    var _a;
+    const object = (0, exports.getReadObject)(config, objectName);
+    return ((_a = object === null || object === void 0 ? void 0 : object.selectedFieldMappings) === null || _a === void 0 ? void 0 : _a[key]) || '';
+}
+exports.getValueFromConfigCustomMapping = getValueFromConfigCustomMapping;
+// aux. get field value based on type guard
+function getFieldKeyValue(field) {
+    if (isIntegrationFieldMapping(field)) {
+        return field.mapToName; // custom mapping
+    }
+    return field.fieldName; // existant field
+}
+exports.getFieldKeyValue = getFieldKeyValue;
+// generates standard objects and whether they are complete based on config and hydrated revision
+function generateNavObjects(config, hydratedRevision) {
+    var _a, _b, _c;
+    const navObjects = [];
+    (_c = (_b = (_a = hydratedRevision.content) === null || _a === void 0 ? void 0 : _a.read) === null || _b === void 0 ? void 0 : _b.standardObjects) === null || _c === void 0 ? void 0 : _c.forEach((object) => {
+        navObjects.push({
+            name: object === null || object === void 0 ? void 0 : object.objectName,
+            // if no config, object is not completed
+            // object is completed if the key exists in the config
+            completed: config ? !!(0, exports.getReadObject)(config, object.objectName) : false,
+        });
+    });
+    return navObjects;
+}
+exports.generateNavObjects = generateNavObjects;

package/build/src/components/OAuthPopup/OAuthPopup.d.ts

@@ -0,0 +1,14 @@
+/**
+ * OAuthPopup.tsx
+ *
+ * Takes a URL and creates a popup showing that page.
+ */
+import React from 'react';
+type PopupProps = {
+    url: string | null;
+    title: string;
+    onClose: (err: string | null) => void;
+    children: React.ReactNode;
+};
+declare function OAuthPopup({ title, url, children, onClose, }: PopupProps): import("react/jsx-runtime").JSX.Element;
+export default OAuthPopup;