@membranehq/react 0.1.0

package/dist/cjs/components/ComboBox/context/helpers.cjs

@@ -0,0 +1,143 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+'use strict';
+
+var sdk = require('@membranehq/sdk');
+var getLookupCollection = require('../Dropdown/Categories/getLookupCollection.cjs');
+var shared = require('../shared.cjs');
+
+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 getAvailableRootCategories({
+  schema,
+  options,
+  optionFactories,
+  variablesOnly,
+  hasVariables,
+  client,
+  connectionId,
+  integrationId
+}) {
+  const availableCategories = /* @__PURE__ */ new Set();
+  const udm = schema?.referenceUdm;
+  const udmSpec = udm ? sdk.UNIFIED_DATA_MODELS[udm] : void 0;
+  if (!!udmSpec) {
+    availableCategories.add(shared.DropdownCategoryType.SELECT_FROM_UDM_DYNAMICALLY);
+  }
+  if (schema && (connectionId || integrationId)) {
+    const collection = await getLookupCollection.getLookupCollection({
+      schema,
+      client,
+      connectionId,
+      integrationId
+    });
+    if (collection?.find?.queryFields || collection?.match?.fields) {
+      availableCategories.add(shared.DropdownCategoryType.SELECT_FROM_UDM_DYNAMICALLY);
+    }
+  }
+  const comboboxHasOptions = Array.isArray(options);
+  const comboboxHasOptionFactories = (optionFactories || []).length > 0;
+  const comboboxHasFixedValues = !!schema && sdk.schemaHasFixedValues(schema);
+  const comboboxHasOptionList = comboboxHasOptions || comboboxHasOptionFactories || comboboxHasFixedValues;
+  if (comboboxHasOptionList) {
+    availableCategories.add(shared.DropdownCategoryType.OPTIONS);
+  }
+  const comboboxHasReferenceCollection = !!sdk.getReferenceCollectionPathForSchema(schema);
+  if (comboboxHasReferenceCollection && connectionId) {
+    availableCategories.add(shared.DropdownCategoryType.LOOKUP_OPTIONS);
+  }
+  const schemaAllowCustomValue = isSchemaAllowCustomValue(schema);
+  if (!variablesOnly && !comboboxHasOptionList && schemaAllowCustomValue) {
+    availableCategories.add(shared.DropdownCategoryType.CUSTOM);
+  }
+  if (hasVariables) {
+    availableCategories.add(shared.DropdownCategoryType.VARIABLE);
+    availableCategories.add(shared.DropdownCategoryType.FORMULA);
+  }
+  return availableCategories.size > 0 ? [...availableCategories] : null;
+}
+function getCurrentPath(availableCategories, value) {
+  if (availableCategories.length < 1) {
+    return [shared.DropdownCategoryType.ROOT];
+  }
+  if (availableCategories.length === 1) {
+    return availableCategories;
+  }
+  const formulaType = sdk.getFormula(value)?.type;
+  if (formulaType === sdk.DataBuilderFormulaType.LOOKUP && availableCategories.includes(shared.DropdownCategoryType.SELECT_FROM_UDM_DYNAMICALLY)) {
+    return [shared.DropdownCategoryType.ROOT, shared.DropdownCategoryType.SELECT_FROM_UDM_DYNAMICALLY];
+  }
+  if (formulaType === sdk.DataBuilderFormulaType.VAR) {
+    return [shared.DropdownCategoryType.ROOT, shared.DropdownCategoryType.VARIABLE];
+  }
+  const generalFormulaTypes = Object.values(sdk.DataBuilderFormulaType).filter(
+    (x) => ![sdk.DataBuilderFormulaType.TPL, sdk.DataBuilderFormulaType.VAR, sdk.DataBuilderFormulaType.RECORD].includes(x)
+  );
+  if (availableCategories.includes(shared.DropdownCategoryType.FORMULA) && generalFormulaTypes.includes(formulaType)) {
+    return [shared.DropdownCategoryType.ROOT, shared.DropdownCategoryType.FORMULA, shared.DropdownCategoryType.FORMULA_CONFIG];
+  }
+  if (availableCategories.includes(shared.DropdownCategoryType.LOOKUP_OPTIONS)) {
+    return [shared.DropdownCategoryType.ROOT];
+  }
+  if (availableCategories.includes(shared.DropdownCategoryType.CUSTOM)) {
+    return [shared.DropdownCategoryType.ROOT];
+  }
+  return [shared.DropdownCategoryType.ROOT];
+}
+async function getStackForPath(path, value, getOptions, stack, searchValue) {
+  const [first, ...rest] = path;
+  if (!first) {
+    return stack;
+  }
+  const options = await getOptions(searchValue, stack);
+  const targetOption = options.find((option) => {
+    const categoryMatched = option.childCategory !== void 0 && option.childCategory === first;
+    if (first === shared.DropdownCategoryType.FORMULA_CONFIG) {
+      const valueFormulaType = sdk.getFormula(value)?.type;
+      const optionFormulaType = sdk.getFormula(option.value)?.type;
+      if (!optionFormulaType && !optionFormulaType) {
+        return false;
+      }
+      return categoryMatched && valueFormulaType === optionFormulaType;
+    }
+    return categoryMatched;
+  });
+  const newStack = [...stack];
+  if (targetOption) {
+    newStack.push(targetOption);
+  }
+  return await getStackForPath(rest, value, getOptions, newStack, searchValue);
+}
+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 && sdk.schemaHasFixedValues(schema)) {
+    return !!schema.allowCustom;
+  }
+  if (schema?.type && ["array", "object", "boolean"].includes(schema?.type)) {
+    return false;
+  }
+  return true;
+}
+
+exports.canUserEnterValueFromKeyboard = canUserEnterValueFromKeyboard;
+exports.getAvailableRootCategories = getAvailableRootCategories;
+exports.getCurrentPath = getCurrentPath;
+exports.getStackForPath = getStackForPath;

package/dist/cjs/components/ComboBox/options-factories/boolean.cjs

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+'use strict';
+
+var svgIconType = require('../../SvgIcon/svg-icon-type.cjs');
+
+class BooleanOptionsFactory {
+  async getOptions({}) {
+    return this.getOptionsSync();
+  }
+  getOptionsSync() {
+    return [
+      {
+        label: "Yes",
+        value: true,
+        iconType: svgIconType.SvgIconType.ListOption
+      },
+      {
+        label: "No",
+        value: false,
+        iconType: svgIconType.SvgIconType.ListOption
+      }
+    ];
+  }
+}
+
+exports.BooleanOptionsFactory = BooleanOptionsFactory;

package/dist/cjs/components/ComboBox/options-factories/constant.cjs

@@ -0,0 +1,29 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+'use strict';
+
+var svgIconType = require('../../SvgIcon/svg-icon-type.cjs');
+var utils = require('./utils.cjs');
+
+class ConstantOptionFactory {
+  constructor(options) {
+    this.options = options;
+  }
+  async getOptions({ input }) {
+    return this.getOptionsSync({ input });
+  }
+  getOptionsSync({ input }) {
+    return utils.filterOptionsByLabel(this.options, input).map((option) => ({
+      ...option,
+      iconType: svgIconType.SvgIconType.ListOption
+    }));
+  }
+}
+
+exports.ConstantOptionFactory = ConstantOptionFactory;

package/dist/cjs/components/ComboBox/options-factories/custom-field/constants.cjs

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+'use strict';
+
+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";
+function isCustomFieldValue(value) {
+  return [JSON.stringify(CUSTOM_OBJECT_VALUE), JSON.stringify(CUSTOM_ARRAY_VALUE)].includes(JSON.stringify(value));
+}
+
+exports.CUSTOM_ARRAY_VALUE = CUSTOM_ARRAY_VALUE;
+exports.CUSTOM_ARRAY_VALUE_LABEL = CUSTOM_ARRAY_VALUE_LABEL;
+exports.CUSTOM_OBJECT_VALUE = CUSTOM_OBJECT_VALUE;
+exports.CUSTOM_OBJECT_VALUE_LABEL = CUSTOM_OBJECT_VALUE_LABEL;
+exports.isCustomFieldValue = isCustomFieldValue;

package/dist/cjs/components/ComboBox/options-factories/custom-field/index.cjs

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+'use strict';
+
+var shared = require('../../shared.cjs');
+var svgIconType = require('../../../SvgIcon/svg-icon-type.cjs');
+var valueSpec = require('../../value-spec.cjs');
+var utils = require('../utils.cjs');
+var constants = require('./constants.cjs');
+
+class CustomFieldOptionsFactory {
+  async getOptions({ spec, input }) {
+    const options = [];
+    if (spec && (spec.type === valueSpec.ValueType.ANY || spec.type === valueSpec.ValueType.OBJECT)) {
+      options.push({
+        label: constants.CUSTOM_OBJECT_VALUE_LABEL,
+        value: constants.CUSTOM_OBJECT_VALUE,
+        iconType: svgIconType.SvgIconType.SchemaType_object
+      });
+    }
+    if (spec && (spec.type === valueSpec.ValueType.ANY || spec.type === valueSpec.ValueType.ARRAY)) {
+      options.push({
+        label: constants.CUSTOM_ARRAY_VALUE_LABEL,
+        value: constants.CUSTOM_ARRAY_VALUE,
+        iconType: svgIconType.SvgIconType.SchemaType_array
+      });
+    }
+    const result = utils.filterOptionsByLabel(options, input);
+    if (result.length > 0) {
+      result.unshift({
+        label: shared.dropdownCategoryConfig[shared.DropdownCategoryType.CUSTOM].title,
+        isSection: true
+      });
+    }
+    return result;
+  }
+}
+
+exports.CustomFieldOptionsFactory = CustomFieldOptionsFactory;

package/dist/cjs/components/ComboBox/options-factories/enum.cjs

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+'use strict';
+
+var svgIconType = require('../../SvgIcon/svg-icon-type.cjs');
+var utils = require('./utils.cjs');
+
+class EnumOptionFactory {
+  constructor(params) {
+    this.params = params;
+  }
+  async getOptions({ input }) {
+    return this.getOptionsSync({ input });
+  }
+  getOptionsSync({ input }) {
+    const options = [];
+    if (this.params.schema.enum && Array.isArray(this.params.schema.enum)) {
+      this.params.schema.enum.map((enumValue) => {
+        if (typeof enumValue == "object" && enumValue.value) {
+          options.push({
+            label: enumValue.label ?? enumValue.value,
+            value: enumValue.value,
+            iconType: svgIconType.SvgIconType.ListOption
+          });
+        } else {
+          options.push({
+            label: enumValue,
+            value: enumValue,
+            iconType: svgIconType.SvgIconType.ListOption
+          });
+        }
+      });
+    }
+    const filteredOptions = utils.filterOptionsByLabel(options, input);
+    if (filteredOptions.length > 0) {
+      return [
+        {
+          label: "Possible Values",
+          iconUri: this.params.iconUri,
+          isSection: true
+        },
+        ...filteredOptions
+      ];
+    } else {
+      return [];
+    }
+  }
+}
+
+exports.EnumOptionFactory = EnumOptionFactory;

package/dist/cjs/components/ComboBox/options-factories/formula/config-mapping.cjs

@@ -0,0 +1,106 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+'use strict';
+
+var sdk = require('@membranehq/sdk');
+var valueSpec = require('../../value-spec.cjs');
+
+const formulaConfigMapping = {
+  [sdk.DataBuilderFormulaType.VAR]: {},
+  [sdk.DataBuilderFormulaType.TPL]: {},
+  [sdk.DataBuilderFormulaType.RECORD]: {},
+  [sdk.DataBuilderFormulaType.FIRST_NAME]: {
+    name: "Extract First Name",
+    appliesToSpec: appliesToString
+  },
+  [sdk.DataBuilderFormulaType.LAST_NAME]: {
+    name: "Extract Last Name",
+    appliesToSpec: appliesToString
+  },
+  [sdk.DataBuilderFormulaType.ITERATE]: {
+    name: "Iterate over a list",
+    appliesToSpec: appliesToArray
+  },
+  [sdk.DataBuilderFormulaType.CONCAT]: {
+    name: "Combine strings",
+    appliesToSpec: appliesToString
+  },
+  [sdk.DataBuilderFormulaType.LOOKUP]: {},
+  [sdk.DataBuilderFormulaType.MAP]: {
+    name: "Mapped Value",
+    appliesToSpec: appliesToAny
+  },
+  [sdk.DataBuilderFormulaType.CASE]: {
+    name: "Conditional Value",
+    appliesToSpec: appliesToAny
+  },
+  [sdk.DataBuilderFormulaType.PLAIN]: {},
+  [sdk.DataBuilderFormulaType.EXTRACT_DATE]: {
+    name: "Extract Date",
+    appliesToSpec: appliesToDate
+  },
+  [sdk.DataBuilderFormulaType.EXTRACT_TIME]: {
+    name: "Extract Time",
+    appliesToSpec: appliesToTime
+  },
+  [sdk.DataBuilderFormulaType.COPY]: {
+    name: "Copy Value from Another Field"
+  },
+  [sdk.DataBuilderFormulaType.FIND_APP_RECORD_ID]: {
+    name: "Find App Record ID",
+    appliesToSpec: appliesToAny
+  },
+  [sdk.DataBuilderFormulaType.FIND_EXTERNAL_RECORD_ID]: {
+    name: "Find External Record ID",
+    appliesToSpec: appliesToAny
+  },
+  [sdk.DataBuilderFormulaType.EVAL]: {},
+  [sdk.DataBuilderFormulaType.AND]: {},
+  [sdk.DataBuilderFormulaType.OR]: {},
+  [sdk.DataBuilderFormulaType.MERGE_OBJECTS]: {
+    name: "Merge Objects",
+    appliesToSpec: appliesToObject
+  },
+  [sdk.DataBuilderFormulaType.FIRST_NOT_EMPTY]: {
+    name: "First Not Empty",
+    appliesToSpec: appliesToAny
+  },
+  [sdk.DataBuilderFormulaType.DOMAIN_FROM_EMAIL]: {
+    name: "Domain From Email",
+    appliesToSpec: appliesToString
+  },
+  [sdk.DataBuilderFormulaType.FORMULA]: {
+    name: "Formula"
+  },
+  [sdk.DataBuilderFormulaType.JSONATA]: {
+    name: "Jsonata Expression",
+    appliesToSpec: appliesToAny
+  },
+  [sdk.DataBuilderFormulaType.DATA_SCHEMA_REF]: {}
+};
+function appliesToAny() {
+  return true;
+}
+function appliesToString(spec) {
+  return Boolean(spec.type === valueSpec.ValueType.STRING && spec.allowCustom);
+}
+function appliesToArray(spec) {
+  return spec.type === valueSpec.ValueType.ARRAY;
+}
+function appliesToDate(spec) {
+  return spec.type === valueSpec.ValueType.DATE;
+}
+function appliesToTime(spec) {
+  return spec.type === valueSpec.ValueType.TIME;
+}
+function appliesToObject(spec) {
+  return spec.type === valueSpec.ValueType.OBJECT;
+}
+
+exports.formulaConfigMapping = formulaConfigMapping;

package/dist/cjs/components/ComboBox/options-factories/formula/index.cjs

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * Integration App React package
+ * {@link https://www.npmjs.com/package/@membranehq/react}
+ * v0.1.0
+ */
+'use client';
+
+'use strict';
+
+var svgIconType = require('../../../SvgIcon/svg-icon-type.cjs');
+var shared = require('../../shared.cjs');
+var valueSpec = require('../../value-spec.cjs');
+var utils = require('../utils.cjs');
+var configMapping = require('./config-mapping.cjs');
+
+class FormulaListOptionsFactory {
+  async getOptions({ input, spec }) {
+    const formulaTypes = getFormulaTypesForSpec(spec);
+    const options = [];
+    for (const type of formulaTypes) {
+      const formulaSpec = configMapping.formulaConfigMapping[type];
+      options.push({
+        label: formulaSpec.name,
+        value: {
+          [`$${type}`]: null
+        },
+        childCategory: shared.DropdownCategoryType.FORMULA_CONFIG,
+        iconType: svgIconType.SvgIconType.ListOption
+      });
+    }
+    const filteredOptions = utils.filterOptionsByLabel(options, input);
+    if (filteredOptions.length > 0) {
+      filteredOptions.unshift({
+        label: shared.dropdownCategoryConfig[shared.DropdownCategoryType.FORMULA].title,
+        isSection: true
+      });
+    }
+    return filteredOptions;
+  }
+}
+function getFormulaTypesForSpec(spec) {
+  const result = [];
+  const entries = Object.entries(configMapping.formulaConfigMapping);
+  for (const [formulaType, formulaSpec] of entries) {
+    if (!formulaSpec.appliesToSpec) {
+      continue;
+    }
+    if (!spec?.type || spec.type === valueSpec.ValueType.ANY || formulaSpec.appliesToSpec(spec)) {
+      result.push(formulaType);
+    }
+  }
+  return result;
+}
+
+exports.FormulaListOptionsFactory = FormulaListOptionsFactory;