@integration-app/react 2.0.3-beta.1 → 2.0.3-beta.2

package/dist/esm/components/ComboBox/context/combobox-dropdown-context.mjs

@@ -0,0 +1,218 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useState, useEffect, useCallback, useContext } from 'react';
+import usePromise from '../../../_modules/react-use-promise.mjs';
+import deepEqual from 'fast-deep-equal';
+import { FormulaListOptionsFactory } from '../../DataBuilder/Formula/options-factory.mjs';
+import { SvgIconType } from '../../SvgIcon/index.mjs';
+import { useIntegrationAppClient } from '../../../contexts/integration-app-client-context.mjs';
+import { useIntegrationAppConnection } from '../../../contexts/integration-app-connection-context.mjs';
+import { useIntegrationAppIntegration } from '../../../contexts/integration-app-integration-context.mjs';
+import 'fuse';
+import { BooleanOptionsFactory } from '../options-factories/boolean.mjs';
+import { ConstantOptionFactory } from '../options-factories/constant.mjs';
+import { CustomFieldOptionsFactory } from '../options-factories/custom-field.mjs';
+import { EnumOptionFactory } from '../options-factories/enum.mjs';
+import 'js-convert-case';
+import '@integration-app/sdk';
+import { SchemaOptionFactory } from '../options-factories/schema.mjs';
+import { ReferenceRecordsOptionsFactory } from '../options-factories/reference-records.mjs';
+import { ReferenceUdmOptionFactory } from '../options-factories/reference-udm.mjs';
+import { ComboBoxTabType } from '../types.mjs';
+import { getAvailableTabs, getCurrentTab } from './helpers.mjs';
+import { useComboBox } from './combobox-context.mjs';
+import useDataBuilder from '../../DataBuilder/data-builder-context.mjs';
+
+const ComboBoxDropdownContext = createContext({
+  availableTabs: [],
+  activeTab: ComboBoxTabType.VARIABLE,
+  setActiveTab: () => null,
+  resetActiveTab: () => null,
+  isOptionSelected: () => false,
+  generateOptions: () => [[]]
+});
+ComboBoxDropdownContext.displayName = "ComboBoxDropdownContext";
+const ComboBoxDropdownContextProvider = ({
+  children
+}) => {
+  const { editableVariablesSchemaLocators } = useDataBuilder();
+  const {
+    value,
+    schema,
+    valueSpec,
+    variablesSchema,
+    variablesOnly,
+    options,
+    optionFactories
+  } = useComboBox();
+  const { client } = useIntegrationAppClient();
+  const { connectionId } = useIntegrationAppConnection();
+  const { integrationId } = useIntegrationAppIntegration();
+  const [currentTab, setCurrentTab] = useState(null);
+  const [availableTabs, setAvailableTabs] = useState(
+    null
+  );
+  const hasVariables = variablesSchema?.type === "object" && Object.keys(variablesSchema.properties ?? {}).length > 0;
+  useEffect(() => {
+    void getAvailableTabs({
+      schema,
+      options,
+      optionFactories,
+      variablesOnly,
+      hasVariables,
+      client,
+      connectionId,
+      integrationId
+    }).then((tabs) => {
+      setAvailableTabs(tabs);
+    });
+  }, [
+    schema,
+    options,
+    optionFactories,
+    variablesOnly,
+    hasVariables,
+    client,
+    integrationId,
+    connectionId
+  ]);
+  const activeTab = availableTabs ? getCurrentTab(availableTabs, currentTab, value) : null;
+  const generateOptions = function(searchValue, drilldownStack) {
+    return usePromise(
+      () => getOptions({
+        activeTab,
+        // @ts-expect-error TS(2345): Argument of type 'DataSchema | undefined' is not a... Remove this comment to see the full error message
+        schema,
+        variablesSchema,
+        searchValue,
+        valueSpec,
+        drilldownStack,
+        options,
+        optionFactories,
+        editableVariablesSchemaLocators
+      }),
+      [
+        activeTab,
+        JSON.stringify(schema),
+        JSON.stringify(variablesSchema),
+        searchValue,
+        JSON.stringify(valueSpec),
+        drilldownStack.length.toString(),
+        JSON.stringify(options),
+        optionFactories?.length,
+        JSON.stringify(editableVariablesSchemaLocators)
+      ]
+    );
+  };
+  const isOptionSelected = useCallback(
+    function(option) {
+      return deepEqual(option.value, value);
+    },
+    [value]
+  );
+  return /* @__PURE__ */ jsx(
+    ComboBoxDropdownContext.Provider,
+    {
+      value: {
+        availableTabs,
+        activeTab,
+        setActiveTab: setCurrentTab,
+        resetActiveTab: () => setCurrentTab(null),
+        isOptionSelected,
+        generateOptions
+      },
+      children
+    }
+  );
+};
+function useComboBoxDropdownContext() {
+  return useContext(ComboBoxDropdownContext);
+}
+async function getOptions({
+  activeTab,
+  schema,
+  variablesSchema,
+  searchValue,
+  valueSpec,
+  drilldownStack,
+  options: staticOptions,
+  optionFactories,
+  editableVariablesSchemaLocators
+}) {
+  const factories = [...optionFactories];
+  switch (activeTab) {
+    case ComboBoxTabType.OPTIONS:
+      if (schema?.referenceUdm) {
+        factories.unshift(new ReferenceUdmOptionFactory(schema));
+      } else if (schema?.referenceRecords) {
+        factories.push(new ReferenceRecordsOptionsFactory({ schema }));
+      } else if (schema?.enum) {
+        factories.push(new EnumOptionFactory({ schema }));
+      } else if (schema?.type === "boolean") {
+        factories.push(new BooleanOptionsFactory());
+      } else if (staticOptions) {
+        factories.push(new ConstantOptionFactory(staticOptions));
+      }
+      break;
+    case ComboBoxTabType.VARIABLE:
+      factories.push(
+        new SchemaOptionFactory({
+          schema: variablesSchema,
+          editableSchemaLocators: editableVariablesSchemaLocators
+        })
+      );
+      break;
+    case ComboBoxTabType.FORMULA:
+      factories.push(new FormulaListOptionsFactory());
+      break;
+    case ComboBoxTabType.CUSTOM:
+      factories.push(new CustomFieldOptionsFactory());
+      break;
+  }
+  const options = [];
+  async function getOptionsFromFactory(factory) {
+    const result = [];
+    result.push(
+      ...await factory.getOptions({ input: searchValue, spec: valueSpec })
+    );
+    if (searchValue) {
+      const unfilteredOptions = await factory.getOptions({
+        input: "",
+        spec: valueSpec
+      });
+      for (const option of unfilteredOptions) {
+        if (option.drilldownOptionFactories) {
+          for (const drilldownFactory of option.drilldownOptionFactories) {
+            result.push(...await getOptionsFromFactory(drilldownFactory));
+          }
+        }
+      }
+    }
+    return result;
+  }
+  if (drilldownStack.length > 0) {
+    options.push({
+      label: "Back",
+      iconType: SvgIconType.ChevronLeft,
+      drillup: true
+    });
+    const option = drilldownStack[drilldownStack.length - 1];
+    for (const drilldownFactory of option?.drilldownOptionFactories ?? []) {
+      options.push(...await getOptionsFromFactory(drilldownFactory));
+    }
+  } else {
+    for (const optionFactory of [...factories]) {
+      options.push(...await getOptionsFromFactory(optionFactory));
+    }
+  }
+  return options;
+}
+
+export { ComboBoxDropdownContextProvider, useComboBoxDropdownContext };

package/dist/esm/components/ComboBox/context/combobox-dropdown-search.mjs

@@ -0,0 +1,51 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useState, useMemo, useContext } from 'react';
+
+const ComboBoxDropdownSearchContext = createContext(
+  {
+    hideSearch: false,
+    searchValue: "",
+    setSearchValue: () => null,
+    drillDownDepth: 0,
+    setDrillDownDepth: () => {
+    },
+    searchSource: "editor",
+    setSearchSource: () => {
+    }
+  }
+);
+ComboBoxDropdownSearchContext.displayName = "ComboBoxDropdownSearchContext";
+const ComboBoxDropdownSearchProvider = ({
+  children,
+  hideSearch = false
+}) => {
+  const [searchValue, setSearchValue] = useState("");
+  const [drillDownDepth, setDrillDownDepth] = useState(0);
+  const [searchSource, setSearchSource] = useState("editor");
+  const contextValue = useMemo(
+    () => ({
+      searchValue,
+      setSearchValue,
+      hideSearch,
+      drillDownDepth,
+      setDrillDownDepth,
+      searchSource,
+      setSearchSource
+    }),
+    [searchValue, hideSearch, drillDownDepth, searchSource]
+  );
+  return /* @__PURE__ */ jsx(ComboBoxDropdownSearchContext.Provider, { value: contextValue, children });
+};
+function useComboBoxDropdownSearchContext() {
+  return useContext(ComboBoxDropdownSearchContext);
+}
+
+export { ComboBoxDropdownSearchProvider, useComboBoxDropdownSearchContext };

package/dist/esm/components/ComboBox/context/combobox-dropdown-stack.mjs

@@ -0,0 +1,54 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { createContext, useContext, useRef, useEffect } from 'react';
+import { getRefElement } from '../../../helpers/getRefElement.mjs';
+
+const DropdownStackContext = createContext(false);
+let GLOBAL_DROPDOWN_STACK = [];
+const DropdownStackContextProvider = ({
+  children
+}) => {
+  const hasNestedDropdownsContext = useContext(DropdownStackContext);
+  if (hasNestedDropdownsContext) {
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  return /* @__PURE__ */ jsx(DropdownStackContext.Provider, { value: true, children });
+};
+const useDropdownStackContext = (dropdownRef) => {
+  const isNested = useContext(DropdownStackContext);
+  const recordRef = useRef(dropdownRef);
+  useEffect(() => {
+    if (isNested) {
+      GLOBAL_DROPDOWN_STACK.push(recordRef?.current);
+    } else {
+      GLOBAL_DROPDOWN_STACK = [recordRef?.current];
+    }
+    return () => {
+      GLOBAL_DROPDOWN_STACK = GLOBAL_DROPDOWN_STACK.filter(
+        (record) => record !== recordRef?.current
+      );
+    };
+  }, []);
+  function isClickInsideRefsAndChildren(event) {
+    const stackStartedFromElement = GLOBAL_DROPDOWN_STACK.slice(
+      GLOBAL_DROPDOWN_STACK.indexOf(recordRef?.current)
+    );
+    return stackStartedFromElement.some((ref) => {
+      return isClickInsideRefRecord(ref, event);
+    });
+  }
+  return { isClickInsideRefsAndChildren };
+};
+function isClickInsideRefRecord(record, event) {
+  const element = getRefElement(record);
+  return !!(element && element.contains(event.target));
+}
+
+export { DropdownStackContextProvider, useDropdownStackContext };

package/dist/esm/components/ComboBox/context/helpers.mjs

@@ -0,0 +1,126 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+import { UNIFIED_DATA_MODELS, schemaHasFixedValues, getReferenceCollectionPathForSchema, getFormula, DataBuilderFormulaType } from '@integration-app/sdk';
+import { ComboBoxTabType } from '../types.mjs';
+import { getLookupCollection } from '../Dropdown/Tabs/Lookup.mjs';
+
+function isSchemaAllowCustomValue(schema) {
+  const schemaHasNoType = !schema?.type;
+  const schemaIsObjectWithNoProperties = schema?.type === "object" && Object.keys(schema.properties ?? {}).length === 0;
+  const schemaIsArrayWithNoSchemaItems = schema?.type === "array" && !schema?.items?.type;
+  return schemaHasNoType || schemaIsObjectWithNoProperties || schemaIsArrayWithNoSchemaItems;
+}
+async function getAvailableTabs({
+  schema,
+  options,
+  optionFactories,
+  variablesOnly,
+  hasVariables,
+  client,
+  connectionId,
+  integrationId
+}) {
+  const availableTabs = [];
+  const udm = schema?.referenceUdm;
+  const udmSpec = udm ? UNIFIED_DATA_MODELS[udm] : void 0;
+  if (!!udmSpec) {
+    availableTabs.push(ComboBoxTabType.SELECT_FROM_UDM_DYNAMICALLY);
+  }
+  const comboboxHasOptions = Array.isArray(options);
+  const comboboxHasOptionFactories = (optionFactories || []).length > 0;
+  const comboboxHasFixedValues = !!schema && schemaHasFixedValues(schema);
+  const comboboxHasOptionList = comboboxHasOptions || comboboxHasOptionFactories || comboboxHasFixedValues;
+  if (comboboxHasOptionList) {
+    availableTabs.push(ComboBoxTabType.OPTIONS);
+  }
+  const comboboxHasReferenceCollection = !!getReferenceCollectionPathForSchema(schema);
+  if (comboboxHasReferenceCollection && connectionId) {
+    availableTabs.push(ComboBoxTabType.LOOKUP_OPTIONS);
+  }
+  if (schema && (connectionId || integrationId)) {
+    const collection = await getLookupCollection({
+      schema,
+      client,
+      connectionId,
+      integrationId
+    });
+    if (collection?.find?.queryFields || collection?.match?.fields) {
+      availableTabs.push(ComboBoxTabType.SELECT_FROM_COLLECTION_DYNAMICALLY);
+    }
+  }
+  const schemaAllowCustomValue = isSchemaAllowCustomValue(schema);
+  if (!variablesOnly && !comboboxHasOptionList && schemaAllowCustomValue) {
+    availableTabs.push(ComboBoxTabType.CUSTOM);
+  }
+  if (hasVariables) {
+    availableTabs.push(ComboBoxTabType.VARIABLE);
+    availableTabs.push(ComboBoxTabType.FORMULA);
+  }
+  return availableTabs.length > 0 ? availableTabs : null;
+}
+function getCurrentTab(availableTabs, possibleCurrentTab, value) {
+  if (possibleCurrentTab && availableTabs.includes(possibleCurrentTab)) {
+    return possibleCurrentTab;
+  }
+  return getDefaultTab(availableTabs, value);
+}
+function getDefaultTab(availableTabs, value) {
+  if (availableTabs.length <= 1) {
+    return availableTabs[0];
+  }
+  const formulaType = getFormula(value)?.type;
+  if (formulaType === DataBuilderFormulaType.LOOKUP) {
+    if (availableTabs.includes(ComboBoxTabType.SELECT_FROM_COLLECTION_DYNAMICALLY)) {
+      return ComboBoxTabType.SELECT_FROM_COLLECTION_DYNAMICALLY;
+    }
+    if (availableTabs.includes(ComboBoxTabType.SELECT_FROM_UDM_DYNAMICALLY)) {
+      return ComboBoxTabType.SELECT_FROM_UDM_DYNAMICALLY;
+    }
+  }
+  const generalFormulaTypes = Object.values(DataBuilderFormulaType).filter(
+    (x) => ![
+      DataBuilderFormulaType.TPL,
+      DataBuilderFormulaType.VAR,
+      DataBuilderFormulaType.RECORD
+    ].includes(x)
+  );
+  if (availableTabs.includes(ComboBoxTabType.FORMULA) && generalFormulaTypes.includes(formulaType)) {
+    return ComboBoxTabType.FORMULA;
+  }
+  if (availableTabs.includes(ComboBoxTabType.OPTIONS)) {
+    return ComboBoxTabType.OPTIONS;
+  }
+  if (availableTabs.includes(ComboBoxTabType.LOOKUP_OPTIONS)) {
+    return ComboBoxTabType.LOOKUP_OPTIONS;
+  }
+  if (availableTabs.includes(ComboBoxTabType.VARIABLE)) {
+    return ComboBoxTabType.VARIABLE;
+  }
+  return availableTabs[0];
+}
+function canUserEnterValueFromKeyboard(schema, options, optionFactories, variablesOnly, value) {
+  const comboboxHasOptions = (options || []).length > 0;
+  const comboboxHasOptionFactories = (optionFactories || []).length > 0;
+  if (variablesOnly || comboboxHasOptions || comboboxHasOptionFactories) {
+    return false;
+  }
+  const valueIsLookup = !!value?.$lookup;
+  if (valueIsLookup) {
+    return false;
+  }
+  if (schema && schemaHasFixedValues(schema)) {
+    return !!schema.allowCustom;
+  }
+  if (schema?.type && ["array", "object", "boolean"].includes(schema?.type)) {
+    return false;
+  }
+  return true;
+}
+
+export { canUserEnterValueFromKeyboard, getAvailableTabs, getCurrentTab };

package/dist/esm/components/ComboBox/index.mjs

@@ -0,0 +1,95 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+import { jsx } from 'react/jsx-runtime';
+import { ComboBoxProvider } from './context/combobox-context.mjs';
+export { useComboBox } from './context/combobox-context.mjs';
+import { ValueType } from './value-spec.mjs';
+export { doesSchemaMatchValueType, getValueSpecFromSchema } from './value-spec.mjs';
+import { ComboBoxDropdownContextProvider } from './context/combobox-dropdown-context.mjs';
+export { useComboBoxDropdownContext } from './context/combobox-dropdown-context.mjs';
+import { ComboBoxDropdownSearchProvider } from './context/combobox-dropdown-search.mjs';
+export { useComboBoxDropdownSearchContext } from './context/combobox-dropdown-search.mjs';
+import { canUserEnterValueFromKeyboard } from './context/helpers.mjs';
+export { getAvailableTabs, getCurrentTab } from './context/helpers.mjs';
+import { OptionSelector } from './Edit/OptionSelector.mjs';
+import { TextInput } from './Edit/TextInput.mjs';
+import 'fuse';
+import '../SvgIcon/index.mjs';
+import 'js-convert-case';
+import '@integration-app/sdk';
+import 'react';
+import '../Tag/styles.module.css.mjs';
+export { DropdownStackContextProvider, useDropdownStackContext } from './context/combobox-dropdown-stack.mjs';
+export { ComboBoxValue } from './Value/index.mjs';
+
+function ComboBox({
+  value,
+  schema,
+  valueSpec = { type: ValueType.ANY, allowCustom: true },
+  variablesSchema,
+  variablesOnly = false,
+  options = void 0,
+  optionFactories = [],
+  onChange,
+  valueComponent = void 0,
+  placeholder = "",
+  isRequired = false,
+  disabled = false,
+  className,
+  hideSearch = false,
+  // Dropdown related
+  autoOpen = false,
+  onOpen,
+  onClose,
+  topDropdownPanelComponent = void 0,
+  refsToIgnoreClick
+}) {
+  const userCanEnterValueFromKeyboard = canUserEnterValueFromKeyboard(
+    schema,
+    options,
+    optionFactories,
+    variablesOnly,
+    value
+  );
+  const dropdownProps = {
+    autoOpen,
+    onDropdownOpen: onOpen,
+    onDropdownClose: onClose,
+    topDropdownPanelComponent
+  };
+  const props = {
+    placeholder,
+    className,
+    onChange,
+    required: isRequired,
+    disabled
+  };
+  return /* @__PURE__ */ jsx(
+    ComboBoxProvider,
+    {
+      value,
+      schema,
+      valueSpec,
+      variablesSchema,
+      options,
+      optionFactories,
+      refsToIgnoreClick,
+      ...dropdownProps,
+      children: /* @__PURE__ */ jsx(ComboBoxDropdownSearchProvider, { hideSearch, children: /* @__PURE__ */ jsx(ComboBoxDropdownContextProvider, { children: userCanEnterValueFromKeyboard ? /* @__PURE__ */ jsx(TextInput, { ...props }) : /* @__PURE__ */ jsx(
+        OptionSelector,
+        {
+          ...props,
+          valueComponent
+        }
+      ) }) })
+    }
+  );
+}
+
+export { ComboBox, ComboBoxDropdownContextProvider, ComboBoxDropdownSearchProvider, ComboBoxProvider, ValueType, canUserEnterValueFromKeyboard };

package/dist/esm/components/ComboBox/options-factories/base.mjs

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+import Fuse from 'fuse';
+
+function filterOptionsByLabel(options, searchString, fuzzy = true) {
+  if (!searchString || typeof searchString !== "string") {
+    return options;
+  }
+  return new Fuse(options, {
+    shouldSort: true,
+    keys: ["searchLabel", "label"],
+    threshold: fuzzy ? 0.3 : 0
+    // 0 = exact match, 1 = match all
+  }).search(searchString.trim()).map(({ item }) => item);
+}
+
+export { filterOptionsByLabel };

package/dist/esm/components/ComboBox/options-factories/boolean.mjs

@@ -0,0 +1,27 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+class BooleanOptionsFactory {
+  async getOptions() {
+    return this.getOptionsSync();
+  }
+  getOptionsSync() {
+    return [
+      {
+        label: "Yes",
+        value: true
+      },
+      {
+        label: "No",
+        value: false
+      }
+    ];
+  }
+}
+
+export { BooleanOptionsFactory };

package/dist/esm/components/ComboBox/options-factories/constant.mjs

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+import { filterOptionsByLabel } from './base.mjs';
+
+class ConstantOptionFactory {
+  constructor(options) {
+    this.options = options;
+  }
+  async getOptions({ input }) {
+    return this.getOptionsSync({ input });
+  }
+  getOptionsSync({ input }) {
+    return filterOptionsByLabel(this.options, input);
+  }
+}
+
+export { ConstantOptionFactory };

package/dist/esm/components/ComboBox/options-factories/custom-field.mjs

@@ -0,0 +1,44 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@integration-app/react}
+ * v2.0.3-beta.2
+ */
+'use client';
+
+import { SvgIconType } from '../../SvgIcon/index.mjs';
+import { ValueType } from '../value-spec.mjs';
+import { filterOptionsByLabel } from './base.mjs';
+
+const CUSTOM_OBJECT_VALUE = {};
+const CUSTOM_OBJECT_VALUE_LABEL = "Object With Custom Fields";
+const CUSTOM_ARRAY_VALUE = [];
+const CUSTOM_ARRAY_VALUE_LABEL = "List With Custom Items";
+class CustomFieldOptionsFactory {
+  async getOptions({ spec, input }) {
+    const options = [];
+    if (spec.type === ValueType.ANY || spec.type === ValueType.OBJECT) {
+      options.push({
+        label: CUSTOM_OBJECT_VALUE_LABEL,
+        value: CUSTOM_OBJECT_VALUE,
+        iconType: SvgIconType.SchemaType_object
+      });
+    }
+    if (spec.type === ValueType.ANY || spec.type === ValueType.ARRAY) {
+      options.push({
+        label: CUSTOM_ARRAY_VALUE_LABEL,
+        value: CUSTOM_ARRAY_VALUE,
+        iconType: SvgIconType.SchemaType_array
+      });
+    }
+    return filterOptionsByLabel(options, input);
+  }
+}
+function isCustomFieldValue(value) {
+  return [
+    JSON.stringify(CUSTOM_OBJECT_VALUE),
+    JSON.stringify(CUSTOM_ARRAY_VALUE)
+  ].includes(JSON.stringify(value));
+}
+
+export { CUSTOM_ARRAY_VALUE, CUSTOM_ARRAY_VALUE_LABEL, CUSTOM_OBJECT_VALUE, CUSTOM_OBJECT_VALUE_LABEL, CustomFieldOptionsFactory, isCustomFieldValue };